Merge remote-tracking branch 'origin/dev_v2.2.0' into dev_v2.2.0

distributed-print-business/src/main/java/com/qmth/distributed/print/business/service/impl/ExamTaskDetailServiceImpl.java

@@ -10,6 +10,7 @@ import com.qmth.distributed.print.business.bean.dto.ExamTaskDetailDto;
 import com.qmth.distributed.print.business.bean.params.RelatePaperParam;
 import com.qmth.distributed.print.business.entity.*;
 import com.qmth.distributed.print.business.enums.ExamDetailStatusEnum;
+import com.qmth.distributed.print.business.enums.ExamStatusEnum;
 import com.qmth.distributed.print.business.enums.PrintPlanStatusEnum;
 import com.qmth.distributed.print.business.mapper.ExamTaskDetailMapper;
 import com.qmth.distributed.print.business.service.*;
@@ -18,12 +19,16 @@ import com.qmth.teachcloud.common.bean.dto.MqDto;
 import com.qmth.teachcloud.common.contant.SystemConstant;
 import com.qmth.teachcloud.common.entity.SysUser;
 import com.qmth.teachcloud.common.enums.ExceptionResultEnum;
+import com.qmth.teachcloud.common.enums.FlowStatusEnum;
 import com.qmth.teachcloud.common.enums.MqTagEnum;
 import com.qmth.teachcloud.common.enums.TaskTypeEnum;
 import com.qmth.teachcloud.common.service.TBTaskService;
 import com.qmth.teachcloud.common.service.TeachcloudCommonService;
 import com.qmth.teachcloud.common.util.RedisUtil;
 import com.qmth.teachcloud.common.util.ServletUtil;
+import org.activiti.engine.TaskService;
+import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.task.Task;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Lazy;
@@ -33,10 +38,7 @@ import org.springframework.util.CollectionUtils;
 
 import javax.annotation.Resource;
 import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 import java.util.stream.Collectors;
 
 /**
@@ -84,6 +86,15 @@ public class ExamTaskDetailServiceImpl extends ServiceImpl<ExamTaskDetailMapper,
     @Resource
     RedisUtil redisUtil;
 
+    @Resource
+    ActivitiService activitiService;
+
+    @Resource
+    TaskService taskService;
+
+    @Autowired
+    TFFlowApproveService tfFlowApproveService;
+
     @Transactional
     @Override
     public boolean enable(ExamTaskDetail examTaskDetail) {
@@ -310,90 +321,150 @@ public class ExamTaskDetailServiceImpl extends ServiceImpl<ExamTaskDetailMapper,
 
     @Override
     public boolean paperUpdate(ExamTaskDetail examTaskDetail) {
-        SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
-        // 提交印刷的考场，不允许修改关联试卷
+
+        validPaperUpdate(examTaskDetail);
+
+        ExamTaskDetail examTaskDetail1 = this.getByExamTaskId(examTaskDetail.getExamTaskId());
+        String unexposedPaperType = examTaskDetail.getPaperType();
+        if (StringUtils.isNotBlank(examTaskDetail1.getExposedPaperType())) {
+            List<String> paperTypeAll = new ArrayList<>(Arrays.asList(examTaskDetail.getPaperType().split(",")));
+            List<String> exposePaperTypes = Arrays.asList(examTaskDetail1.getExposedPaperType().split(","));
+            for (String exposePaperType : exposePaperTypes) {
+                if (paperTypeAll.contains(exposePaperType)) {
+                    paperTypeAll.remove(exposePaperType);
+                }
+            }
+            unexposedPaperType = String.join(",", paperTypeAll);
+        }
+
+        UpdateWrapper<ExamTaskDetail> examTaskDetailUpdateWrapper = new UpdateWrapper<>();
+        examTaskDetailUpdateWrapper.lambda().set(ExamTaskDetail::getPaperType, examTaskDetail.getPaperType())
+                .set(ExamTaskDetail::getPaperAttachmentIds, examTaskDetail.getPaperAttachmentIds())
+                .set(ExamTaskDetail::getCardId, examTaskDetail.getCardId())
+                .set(ExamTaskDetail::getUnexposedPaperType, unexposedPaperType)
+                .eq(ExamTaskDetail::getExamTaskId, examTaskDetail.getExamTaskId());
+        this.update(examTaskDetailUpdateWrapper);
+
         ExamTask examTask = examTaskService.getById(examTaskDetail.getExamTaskId());
         List<ExamDetail> examDetails = examDetailService.listByCourseCodeAndPaperNumber(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber());
-        if (examDetails != null && examDetails.size() > 0) {
-            List<ExamDetail> examDetails1 = examDetails.stream().filter(m -> !ExamDetailStatusEnum.NEW.equals(m.getStatus()) && !ExamDetailStatusEnum.READY.equals(m.getStatus())).collect(Collectors.toList());
+        if(!CollectionUtils.isEmpty(examDetails)) {
+            List<ExamDetail> examDetailList = examDetails.stream().filter(m -> m.getStatus().equals(ExamDetailStatusEnum.WAITING)).collect(Collectors.toList());
+            for (ExamDetail examDetail : examDetailList) {
+                examDetail.setStatus(ExamDetailStatusEnum.NEW);
+                examDetailService.updateById(examDetail);
+            }
+        }
+
+
+        // 不需要审核，直接更新，否则加入待审核列表
+        if (examTask.getReview()) {
+            // 发起新流程
+            //TODO 这里以后要判断学校code来取流程key
+            Map<String, Object> map = new HashMap<>();
+            map.computeIfAbsent(SystemConstant.APPROVE_ID, v -> String.valueOf(examTask.getUserId()));
+            ProcessInstance processInstance = activitiService.startActivity(SystemConstant.GDYKDX_FLOW_KEY, map);
+            Long flowId = Long.parseLong(processInstance.getId());
+            UpdateWrapper<ExamTask> updateWrapper = new UpdateWrapper<>();
+            updateWrapper.lambda().set(ExamTask::getFlowId, flowId).eq(ExamTask::getId, examTaskDetail.getExamTaskId());
+            examTaskService.update(updateWrapper);
+            if (Objects.nonNull(flowId)) {
+                // 审核一级
+                Task task = taskService.createTaskQuery().processInstanceId(String.valueOf(flowId)).singleResult();
+                if (Objects.nonNull(task)) {
+                    Map<String, Object> map1 = new HashMap<>();
+                    map1.computeIfAbsent(SystemConstant.FLOW_TASK_ID, v -> task.getId());
+                    activitiService.taskApprove(map1);
+                }
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public ExamTaskDetail getByExamTaskId(Long examTaskId) {
+        QueryWrapper<ExamTaskDetail> queryWrapper = new QueryWrapper<>();
+        queryWrapper.lambda().eq(ExamTaskDetail::getExamTaskId, examTaskId);
+        return this.getOne(queryWrapper);
+    }
+
+    /**
+     * 卷库校验
+     *
+     * @param examTaskDetail
+     */
+    void validPaperUpdate(ExamTaskDetail examTaskDetail) {
+        // 旧记录
+        ExamTaskDetail examTaskDetailTemp = this.getByExamTaskId(examTaskDetail.getExamTaskId());
+        if (examTaskDetailTemp == null) {
+            throw ExceptionResultEnum.ERROR.exception("命题任务数据异常");
+        }
+
+        List<Map> oldPaperAttachmentIdsList = JSONObject.parseArray(examTaskDetailTemp.getPaperAttachmentIds(), Map.class);
+        List<Map> newPaperAttachmentIdsList = JSONObject.parseArray(examTaskDetail.getPaperAttachmentIds(), Map.class);
+        // 卷型、题卡没有变动，直接return
+        if (oldPaperAttachmentIdsList.size() == newPaperAttachmentIdsList.size()) {
+            String oldString = oldPaperAttachmentIdsList.stream().sorted(Comparator.comparing(m -> m.get("name").toString())).map(m -> m.get("name").toString() + m.get("attachmentId").toString()).collect(Collectors.joining());
+            String newString = newPaperAttachmentIdsList.stream().sorted(Comparator.comparing(m -> m.get("name").toString())).map(m -> m.get("name").toString() + m.get("attachmentId").toString()).collect(Collectors.joining());
+            if (oldString.equals(newString) && examTaskDetailTemp.getCardId().equals(examTaskDetail.getCardId())) {
+                return;
+            }
+        }
+
+        ExamTask examTask = examTaskService.getById(examTaskDetail.getExamTaskId());
+        // 是否审核中
+        TFFlowApprove tfFlowApprove = tfFlowApproveService.findByFlowId(examTask.getFlowId());
+        if (!tfFlowApprove.getStatus().equals(FlowStatusEnum.FINISH)) {
+            throw ExceptionResultEnum.ERROR.exception("命题任务没有审核完成，不能修改卷库");
+        }
+
+        // 提交印刷的考场，不允许修改关联试卷
+        List<ExamDetail> examDetails = examDetailService.listByCourseCodeAndPaperNumber(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber());
+        if (!CollectionUtils.isEmpty(examDetails)) {
+            List<ExamDetail> examDetails1 = examDetails.stream().filter(m -> !ExamDetailStatusEnum.NEW.equals(m.getStatus())
+                    && !ExamDetailStatusEnum.READY.equals(m.getStatus())
+                    && !ExamDetailStatusEnum.WAITING.equals(m.getStatus())).collect(Collectors.toList());
             if (!examDetails1.isEmpty()) {
-                throw ExceptionResultEnum.ERROR.exception("有考场已开始打印，不能修改卷库");
+                throw ExceptionResultEnum.ERROR.exception("印刷任务已开始打印，不能修改卷库");
             }
             Map<Long, List<Long>> map = examDetails.stream().collect(Collectors.groupingBy(ExamDetail::getPrintPlanId, Collectors.mapping(ExamDetail::getId, Collectors.toList())));
             for (Map.Entry<Long, List<Long>> listEntry : map.entrySet()) {
                 boolean b = tbTaskService.countByPrintPlanIdAndEntityId(examTask.getSchoolId(), listEntry.getKey(), listEntry.getValue());
                 if (!b) {
-                    throw ExceptionResultEnum.ERROR.exception("有关联该任务的考场正在生成打印pdf，不能修改卷库");
+                    throw ExceptionResultEnum.ERROR.exception("关联命题任务的考场正在生成打印文件，不能修改卷库");
                 }
             }
         }
 
-        QueryWrapper<ExamTaskDetail> queryWrapper = new QueryWrapper<>();
-        queryWrapper.lambda().eq(ExamTaskDetail::getExamTaskId, examTaskDetail.getExamTaskId());
-        ExamTaskDetail examTaskDetailTemp = this.getOne(queryWrapper);
-        if (examTaskDetailTemp == null) {
-            throw ExceptionResultEnum.ERROR.exception("命题任务数据异常");
-        }
         // 已曝光试卷不能修改
         String exposedPaperType = examTaskDetailTemp.getExposedPaperType();
         if (StringUtils.isNotBlank(exposedPaperType)) {
-            List<Map> oldPaperAttachmentIdsList = JSONObject.parseArray(examTaskDetailTemp.getPaperAttachmentIds(), Map.class);
             Map<String, String> oldPaperAttachmentIdMap = oldPaperAttachmentIdsList.stream().collect(Collectors.toMap(m -> m.get("name").toString(), m -> m.get("attachmentId").toString()));
             String[] exposedPaperTypes = exposedPaperType.split(",");
             String newPaperAttachmentIds = examTaskDetail.getPaperAttachmentIds();
             if (StringUtils.isBlank(newPaperAttachmentIds)) {
                 throw ExceptionResultEnum.ERROR.exception("已曝光试卷不能删除");
             } else {
-                List<Map> newPaperAttachmentIdsList = JSONObject.parseArray(newPaperAttachmentIds, Map.class);
                 Map<String, String> newPaperAttachmentIdMap = newPaperAttachmentIdsList.stream().collect(Collectors.toMap(m -> m.get("name").toString(), m -> m.get("attachmentId").toString()));
                 for (String paperType : exposedPaperTypes) {
+                    if (!oldPaperAttachmentIdMap.containsKey(paperType)) {
+                        throw ExceptionResultEnum.ERROR.exception("原试卷卷型【" + paperType + "】不存在");
+                    }
                     if (!newPaperAttachmentIdMap.containsKey(paperType)) {
-                        throw ExceptionResultEnum.ERROR.exception("已曝光试卷不能删除");
-                    } else {
-                        if (!oldPaperAttachmentIdMap.containsKey(paperType)) {
-                            throw ExceptionResultEnum.ERROR.exception("原试卷卷型有误");
-                        }
-                        String newAttachmentId = newPaperAttachmentIdMap.get(paperType);
-                        String oldAttachmentId = oldPaperAttachmentIdMap.get(paperType);
-                        if (!newAttachmentId.equals(oldAttachmentId)) {
-                            throw ExceptionResultEnum.ERROR.exception("已曝光试卷不能修改");
-                        }
+                        throw ExceptionResultEnum.ERROR.exception("已曝光卷型【" + paperType + "】不能删除");
                     }
-                }
 
+                    String newAttachmentId = newPaperAttachmentIdMap.get(paperType);
+                    String oldAttachmentId = oldPaperAttachmentIdMap.get(paperType);
+                    if (!newAttachmentId.equals(oldAttachmentId)) {
+                        throw ExceptionResultEnum.ERROR.exception("已曝光卷型【" + paperType + "】不能修改试卷文件");
+                    }
+                }
             }
 
-        }
-
-        // 不需要审核，直接更新，否则加入待审核列表
-        if (examTask.getReview()) {
-            // 加入临时审核表
-            ExamTaskPaperLog examTaskPaperLog = examTaskPaperLogService.getByExamTaskIdAndReview(examTaskDetail.getExamTaskId(), false);
-            if (examTaskPaperLog == null) {
-                examTaskPaperLog = new ExamTaskPaperLog();
-                examTaskPaperLog.setId(SystemConstant.getDbUuid());
-                examTaskPaperLog.setExamTaskId(examTaskDetail.getExamTaskId());
-                examTaskPaperLog.setReview(false);
+            // 已有曝光卷型时，题卡不能修改
+            if (!examTaskDetailTemp.getCardId().equals(examTaskDetail.getCardId())) {
+                throw ExceptionResultEnum.ERROR.exception("已有试卷曝光，不能修改题卡");
             }
-            examTaskPaperLog.setPaperType(examTaskDetail.getPaperType());
-            examTaskPaperLog.setPaperAttachmentIds(examTaskDetail.getPaperAttachmentIds());
-            examTaskPaperLog.setCardId(examTaskDetail.getCardId());
-            examTaskPaperLog.setCreateId(sysUser.getId());
-            examTaskPaperLog.setCreateTime(System.currentTimeMillis());
-            examTaskPaperLogService.saveOrUpdate(examTaskPaperLog);
-        } else {
-            UpdateWrapper<ExamTaskDetail> updateWrapper = new UpdateWrapper<>();
-            updateWrapper.lambda().set(ExamTaskDetail::getPaperAttachmentIds, examTaskDetail.getPaperAttachmentIds()).eq(ExamTaskDetail::getExamTaskId, examTaskDetail.getExamTaskId());
-            this.update(updateWrapper);
         }
-        return true;
     }
-
-    @Override
-    public ExamTaskDetail getByExamTaskId(Long examTaskId) {
-        QueryWrapper<ExamTaskDetail> queryWrapper = new QueryWrapper<>();
-        queryWrapper.lambda().eq(ExamTaskDetail::getExamTaskId, examTaskId);
-        return this.getOne(queryWrapper);
-    }
-
 }

distributed-print-business/src/main/java/com/qmth/distributed/print/business/service/impl/ExamTaskServiceImpl.java

@@ -535,14 +535,14 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
                 examTaskDto.setUsers(blurryUserDtoList);
                 String userName = examTaskTempDto.getUserName();
                 String userAccount = examTaskTempDto.getUserAccount();
-                if (SystemConstant.strNotNull(userName) && SystemConstant.strNotNull(userAccount)){
+                if (SystemConstant.strNotNull(userName) && SystemConstant.strNotNull(userAccount)) {
                     List<BlurryUserDto> match = blurryUserDtoList.stream()
                             .filter(e -> e.getLoginName().equals(userAccount) && e.getName().equals(userName))
                             .collect(Collectors.toList());
-                    if (match.size() > 1){
+                    if (match.size() > 1) {
                         throw ExceptionResultEnum.ERROR.exception("数据异常");
                     }
-                    if (match.size() == 1){
+                    if (match.size() == 1) {
                         BlurryUserDto tmp = match.get(0);
                         examTaskDto.setUserId(String.valueOf(tmp.getId()));
                         examTaskDto.setUserName(tmp.getName());
@@ -876,75 +876,21 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
 
     @Transactional
     @Override
-    public boolean saveExamTaskDetail(ExamTaskDetail examTaskDetail) throws IOException {
+    public boolean saveExamTaskDetail(ExamTaskDetail examTaskDetail) {
         SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
         if (examTaskDetail.getExamTaskId() == null) {
             throw ExceptionResultEnum.ERROR.exception("命题任务ID不能为空");
         }
         if (StringUtils.isBlank(examTaskDetail.getOperateType())) {
-            throw ExceptionResultEnum.ERROR.exception("保存类型不能为空");
+            throw ExceptionResultEnum.ERROR.exception("命题任务提交类型不能为空");
         }
         // 提交时，校验
         if (ExamStatusEnum.SUBMIT.name().equals(examTaskDetail.getOperateType())) {
-            if (StringUtils.isBlank(examTaskDetail.getPaperType())) {
-                throw ExceptionResultEnum.ERROR.exception("试卷类型不能为空");
-            }
-            if (StringUtils.isBlank(examTaskDetail.getPaperAttachmentIds())) {
-                throw ExceptionResultEnum.ERROR.exception("试卷ID不能为空");
-            }
-            if (examTaskDetail.getCardId() == null) {
-                throw ExceptionResultEnum.ERROR.exception("题卡ID不能为空");
-            }
-            if (StringUtils.isBlank(examTaskDetail.getPaperConfirmAttachmentIds())) {
-                throw ExceptionResultEnum.ERROR.exception("入库审核ID不能为空");
-            }
-            String[] paperTypes = examTaskDetail.getPaperType().split(",");
-            if (paperTypes.length - examTaskDetail.getDrawCount().intValue() < 0) {
-                throw ExceptionResultEnum.ERROR.exception("单次抽卷数量不能大于卷型数量");
-            }
-
-            // 校验题卡是否提交
-            ExamCard examCard = examCardService.getById(examTaskDetail.getCardId());
-            if (!ExamCardStatusEnum.SUBMIT.name().equals(examCard.getStatus().name())) {
-                throw ExceptionResultEnum.ERROR.exception("请先提交题卡");
-            }
-
-            // 是否强制包含试卷
-            BasicExamRule basicExamRule = basicExamRuleService.getBySchoolId();
-            List<Map> paperAttachmentIds = JSONObject.parseArray(examTaskDetail.getPaperAttachmentIds(), Map.class);
-            // 未上传试卷的类型个数
-            long count = paperAttachmentIds.stream().filter(m -> StringUtils.isBlank(m.get("attachmentId").toString())).count();
-            if (basicExamRule.getIncludePaper()) {
-                if (StringUtils.isBlank(examTaskDetail.getPaperAttachmentIds())) {
-                    throw ExceptionResultEnum.ERROR.exception("试卷文件未上传");
-                }
-                if (count > 0) {
-                    throw ExceptionResultEnum.ERROR.exception("所有类型的试卷文件必须全部上传");
-                }
-            } else {
-                // count == 0为全部上传
-                // paperAttachmentIds.size() == count 为全部未上传
-                if (count != 0 && paperAttachmentIds.size() != count) {
-                    throw ExceptionResultEnum.ERROR.exception("所有类型的试卷文件必须全部上传或全部不上传");
-                }
-            }
+            validSubmitParam(examTaskDetail);
         }
 
         // 更新examTask状态status
         ExamTask examTask = this.getById(examTaskDetail.getExamTaskId());
-        /*if (examTaskDetail.getOperateType().equals(ExamStatusEnum.SUBMIT.name())) {
-            if (Objects.isNull(examTask.getFlowId())) {
-                //TODO 这里以后要判断学校code来取流程key
-                examTask.setStatus(ExamStatusEnum.STAGE);
-                if (examTask.getReview()) {
-                    Map<String, Object> map = new HashMap<>();
-                    map.computeIfAbsent(SystemConstant.APPROVE_ID, v -> String.valueOf(examTask.getUserId()));
-                    ProcessInstance processInstance = activitiService.startActivity(SystemConstant.GDYKDX_FLOW_KEY, map);
-                    examTask.setFlowId(Long.parseLong(processInstance.getId()));
-                }
-            }
-        }*/
-
         UpdateWrapper<ExamTask> updateWrapper = new UpdateWrapper<>();
         updateWrapper.lambda()
                 .set(ExamTask::getStatus, examTaskDetail.getOperateType())
@@ -972,7 +918,18 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
             examTaskDetail.setId(detail.getId());
             // 已曝光试卷和未曝光试卷赋值
             examTaskDetail.setExposedPaperType(detail.getExposedPaperType());
-            examTaskDetail.setUnexposedPaperType(examTaskDetail.getPaperType());
+            if (StringUtils.isNotBlank(detail.getExposedPaperType())) {
+                List<String> paperTypeAll = new ArrayList<>(Arrays.asList(examTaskDetail.getPaperType().split(",")));
+                List<String> exposePaperTypes = Arrays.asList(detail.getExposedPaperType().split(","));
+                for (String exposePaperType : exposePaperTypes) {
+                    if (paperTypeAll.contains(exposePaperType)) {
+                        paperTypeAll.remove(exposePaperType);
+                    }
+                }
+                examTaskDetail.setUnexposedPaperType(String.join(",", paperTypeAll));
+            } else {
+                examTaskDetail.setUnexposedPaperType(examTaskDetail.getPaperType());
+            }
         } else {
             // 已曝光试卷和未曝光试卷赋值（新增时，已曝光试卷为null，未曝光试卷为paper_type）
             examTaskDetail.setUnexposedPaperType(examTaskDetail.getPaperType());
@@ -1348,6 +1305,9 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
         if (examTaskDetail == null) {
             throw ExceptionResultEnum.ERROR.exception("命题任务不存在");
         }
+        if (StringUtils.isNotBlank(examTaskDetail.getExposedPaperType())) {
+            throw ExceptionResultEnum.ERROR.exception("已有试卷曝光，不能切换题卡");
+        }
         if (Objects.nonNull(examTaskDetail.getCardId())) {
             ExamCard examCard = examCardService.getById(examTaskDetail.getCardId());
             if (examCard == null) {
@@ -1461,47 +1421,7 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
 
             // 提交时，校验
             if (ExamStatusEnum.SUBMIT.name().equals(examTaskDetail.getOperateType())) {
-                if (StringUtils.isBlank(examTaskDetail.getPaperType())) {
-                    throw ExceptionResultEnum.ERROR.exception("试卷类型不能为空");
-                }
-                if (StringUtils.isBlank(examTaskDetail.getPaperAttachmentIds())) {
-                    throw ExceptionResultEnum.ERROR.exception("试卷ID不能为空");
-                }
-                if (examTaskDetail.getCardId() == null) {
-                    throw ExceptionResultEnum.ERROR.exception("题卡ID不能为空");
-                }
-                if (StringUtils.isBlank(examTaskDetail.getPaperConfirmAttachmentIds())) {
-                    throw ExceptionResultEnum.ERROR.exception("入库审核ID不能为空");
-                }
-                String[] paperTypes = examTaskDetail.getPaperType().split(",");
-                if (paperTypes.length - examTaskDetail.getDrawCount().intValue() < 0) {
-                    throw ExceptionResultEnum.ERROR.exception("单次抽卷数量不能大于卷型数量");
-                }
-
-                // 校验题卡是否提交
-                ExamCard examCard = examCardService.getById(examTaskDetail.getCardId());
-                if (!ExamCardStatusEnum.SUBMIT.name().equals(examCard.getStatus().name())) {
-                    throw ExceptionResultEnum.ERROR.exception("请先提交题卡");
-                }
-
-                // 是否强制包含试卷
-                List<Map> paperAttachmentIds = JSONObject.parseArray(examTaskDetail.getPaperAttachmentIds(), Map.class);
-                // 未上传试卷的类型个数
-                long count = paperAttachmentIds.stream().filter(m -> StringUtils.isBlank(m.get("attachmentId").toString())).count();
-                if (basicExamRule.getIncludePaper()) {
-                    if (StringUtils.isBlank(examTaskDetail.getPaperAttachmentIds())) {
-                        throw ExceptionResultEnum.ERROR.exception("试卷文件未上传");
-                    }
-                    if (count > 0) {
-                        throw ExceptionResultEnum.ERROR.exception("所有类型的试卷文件必须全部上传");
-                    }
-                } else {
-                    // count == 0为全部上传
-                    if (count != 0 && paperAttachmentIds.size() != count) {
-                        throw ExceptionResultEnum.ERROR.exception("所有类型的试卷文件必须全部上传或全部不上传");
-                    }
-                }
-
+                validSubmitParam(examTaskDetail);
                 if (Objects.nonNull(examTask.getFlowId())) {
                     // 审核一级
                     Task task = taskService.createTaskQuery().processInstanceId(String.valueOf(examTask.getFlowId())).singleResult();
@@ -1579,4 +1499,48 @@ public class ExamTaskServiceImpl extends ServiceImpl<ExamTaskMapper, ExamTask> i
     public List<Long> findFlowIdToNotMySelf(Long currentUserId) {
         return examTaskMapper.findFlowIdToNotMySelf(currentUserId);
     }
+
+    /**
+     * 简单校验提交参数
+     *
+     * @param examTaskDetail
+     */
+    void validSubmitParam(ExamTaskDetail examTaskDetail) {
+        if (StringUtils.isBlank(examTaskDetail.getPaperType())) {
+            throw ExceptionResultEnum.ERROR.exception("没有设置卷型");
+        }
+        if (examTaskDetail.getCardId() == null) {
+            throw ExceptionResultEnum.ERROR.exception("没有绑定题卡");
+        }
+
+        String[] paperTypes = examTaskDetail.getPaperType().split(",");
+        if (paperTypes.length - examTaskDetail.getDrawCount().intValue() < 0) {
+            throw ExceptionResultEnum.ERROR.exception("单次抽卷数量不能大于卷型数量");
+        }
+
+        // 校验题卡是否提交
+        ExamCard examCard = examCardService.getById(examTaskDetail.getCardId());
+        if (!ExamCardStatusEnum.SUBMIT.name().equals(examCard.getStatus().name())) {
+            throw ExceptionResultEnum.ERROR.exception("绑定的题卡未提交");
+        }
+
+        // 是否强制包含试卷
+        BasicExamRule basicExamRule = basicExamRuleService.getBySchoolId();
+        List<Map> paperAttachmentIds = JSONObject.parseArray(examTaskDetail.getPaperAttachmentIds(), Map.class);
+        // 未上传试卷的类型个数
+        long count = paperAttachmentIds.stream().filter(m -> StringUtils.isBlank(m.get("attachmentId").toString())).count();
+        if (basicExamRule.getIncludePaper()) {
+            if (CollectionUtils.isEmpty(paperAttachmentIds)) {
+                throw ExceptionResultEnum.ERROR.exception("没有设置卷型");
+            }
+            if (count > 0) {
+                throw ExceptionResultEnum.ERROR.exception("有部分卷型未上传试卷文件");
+            }
+        } else {
+            // count == 0为全部上传，paperAttachmentIds.size() == count 为全部未上传
+            if (count > 0 && paperAttachmentIds.size() != count) {
+                throw ExceptionResultEnum.ERROR.exception("所有卷型的试卷文件必须全部上传或全部不上传");
+            }
+        }
+    }
 }

distributed-print-business/src/main/resources/mapper/ExamTaskMapper.xml

@@ -487,21 +487,22 @@
     </select>
     <select id="applyGetOne" resultType="com.qmth.distributed.print.business.bean.dto.ExamTaskDetailCardDto">
         SELECT
-            a.exam_task_id examTaskId,
+            e.id examTaskId,
             case #{source} when 'REVIEW' then ifnull(c.paper_type, a.paper_type) else a.paper_type end paperType,
             case #{source} when 'REVIEW' then ifnull(c.paper_attachment_ids, a.paper_attachment_ids) else a.paper_attachment_ids end paperAttachmentIds,
             case #{source} when 'REVIEW' then ifnull(c.card_id, a.card_id) else a.card_id end cardId,
             a.paper_confirm_attachment_ids paperConfirmAttachmentIds,
             a.remark,
+            a.exposed_paper_type exposedPaperType,
             ifnull(d.make_method, a.make_method) makeMethod,
             a.draw_count drawCount,
             ifnull(d.status, b.status) status,
             e.flow_id flowId,
             f.setup
         FROM
-            exam_task_detail a
+            exam_task e
                 LEFT JOIN
-            exam_task e on a.exam_task_id = e.id
+            exam_task_detail a on a.exam_task_id = e.id
                 LEFT JOIN
             exam_task_paper_log c ON a.exam_task_id = c.exam_task_id and c.review = false
                 LEFT JOIN
@@ -510,7 +511,7 @@
             exam_card d on c.card_id = d.id
                 left join
             t_f_flow_approve f on e.flow_id = f.flow_id
-        where a.exam_task_id = #{examTaskId}
+        where e.id = #{examTaskId}
     </select>
 
     <select id="queryByMyWork" resultType="com.qmth.distributed.print.business.bean.result.WorkResult">

distributed-print/src/main/java/com/qmth/distributed/print/api/ExamTaskController.java

@@ -21,9 +21,7 @@ import com.qmth.teachcloud.common.contant.SystemConstant;
 import com.qmth.teachcloud.common.entity.BasicAttachment;
 import com.qmth.teachcloud.common.entity.SysUser;
 import com.qmth.teachcloud.common.entity.TBTask;
-import com.qmth.teachcloud.common.enums.ExceptionResultEnum;
-import com.qmth.teachcloud.common.enums.TaskTypeEnum;
-import com.qmth.teachcloud.common.enums.UploadFileEnum;
+import com.qmth.teachcloud.common.enums.*;
 import com.qmth.teachcloud.common.service.BasicAttachmentService;
 import com.qmth.teachcloud.common.service.BasicStudentService;
 import com.qmth.teachcloud.common.service.TBTaskService;
@@ -34,6 +32,7 @@ import io.swagger.annotations.*;
 import org.activiti.engine.TaskService;
 import org.activiti.engine.task.Task;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.CollectionUtils;
 import org.springframework.validation.BindingResult;
 import org.springframework.web.bind.annotation.*;
 import org.springframework.web.multipart.MultipartFile;
@@ -57,7 +56,6 @@ import java.util.stream.Collectors;
 @Api(tags = "命题任务Controller")
 @RestController
 @RequestMapping(ApiConstant.DEFAULT_URI_PREFIX + "/${prefix.url.exam}/task")
-//@Aac(auth = BOOL.FALSE, strict = BOOL.FALSE)
 public class ExamTaskController {
 
     @Autowired
@@ -90,6 +88,10 @@ public class ExamTaskController {
     @Resource
     private BasicStudentService basicStudentService;
 
+    @Resource
+    ActivitiService activitiService;
+
+
     /**
      * 命题任务管理-查询
      *
@@ -153,36 +155,36 @@ public class ExamTaskController {
     }
 
     /**
-     * 更改/指派命题老师
+     * 命题任务管理-更改/指派命题老师
      *
      * @param examTask
      * @return
      */
-    @ApiOperation(value = "更改/指派命题老师")
+    @ApiOperation(value = "命题任务管理-更改/指派命题老师")
     @RequestMapping(value = "/assign_user", method = RequestMethod.POST)
     public Result assignUser(@RequestBody ExamTask examTask) {
         return ResultUtil.ok(examTaskService.assignUser(examTask));
     }
 
     /**
-     * 启用/禁用
+     * 命题任务管理-启用/禁用
      *
      * @param examTask
      * @return
      */
-    @ApiOperation(value = "启用/禁用")
+    @ApiOperation(value = "命题任务管理-启用/禁用")
     @RequestMapping(value = "/enable", method = RequestMethod.POST)
     public Result enable(@RequestBody ExamTask examTask) {
         return ResultUtil.ok(examTaskService.enable(examTask));
     }
 
     /**
-     * 新建命题任务
+     * 命题任务管理-新建命题任务
      *
      * @param examTask
      * @return
      */
-    @ApiOperation(value = "新建命题任务")
+    @ApiOperation(value = "命题任务管理-新建命题任务")
     @RequestMapping(value = "/save", method = RequestMethod.POST)
     public Result save(@RequestBody ExamTask examTask) {
         ExamTask task = examTaskService.saveExamTaskNew(examTask);
@@ -194,12 +196,12 @@ public class ExamTaskController {
     }
 
     /**
-     * 文件导入
+     * 命题任务管理-文件导入
      *
      * @param file
      * @return
      */
-    @ApiOperation(value = "文件导入")
+    @ApiOperation(value = "命题任务管理-文件导入")
     @RequestMapping(value = "/import", method = RequestMethod.POST)
     public Result importFile(@ApiParam(value = "上传文件", required = true) @RequestParam MultipartFile file) {
         BasicAttachment basicAttachment = null;
@@ -225,12 +227,12 @@ public class ExamTaskController {
     }
 
     /**
-     * 批量保存命题任务
+     * 命题任务管理-批量保存命题任务
      *
      * @param task
      * @return
      */
-    @ApiOperation(value = "批量保存命题任务")
+    @ApiOperation(value = "命题任务管理-批量保存命题任务")
     @RequestMapping(value = "/save_batch", method = RequestMethod.POST)
     public Result saveBatch(@RequestBody ExamTask task) {
         List<ExamTask> examTasks = examTaskService.saveBatch(task);
@@ -256,7 +258,7 @@ public class ExamTaskController {
     }
 
     /**
-     * 入库申请查询
+     * 入库申请-查询
      *
      * @param auditStatus
      * @param cardRuleId
@@ -269,7 +271,7 @@ public class ExamTaskController {
      * @param pageSize
      * @return
      */
-    @ApiOperation(value = "入库申请查询")
+    @ApiOperation(value = "入库申请-查询")
     @RequestMapping(value = "/apply_list", method = RequestMethod.POST)
     public Result taskApplyList(@RequestParam(value = "auditStatus", required = false) String auditStatus,
                                 @RequestParam(value = "cardRuleId", required = false) String cardRuleId,
@@ -286,14 +288,12 @@ public class ExamTaskController {
     /**
      * 根据命题任务ID查询单个数据
      *
-     * @param request
      * @param examTaskId
      * @return
      */
     @ApiOperation(value = "根据命题任务ID查询单个数据")
     @RequestMapping(value = "/apply_get_one", method = RequestMethod.POST)
-    public Result applyGetOne(HttpServletRequest request,
-                              @RequestParam(value = "examTaskId", required = true) Long examTaskId,
+    public Result applyGetOne(@RequestParam(value = "examTaskId") Long examTaskId,
                               @RequestParam(value = "source", required = false) String source) {
         ExamTaskDetailCardDto detail = examTaskService.applyGetOne(examTaskId, source);
         if (Objects.nonNull(detail) && Objects.nonNull(detail.getFlowId())) {
@@ -306,12 +306,12 @@ public class ExamTaskController {
     }
 
     /**
-     * 暂存/提交
+     * 入库申请-暂存/提交
      *
      * @param examTaskDetail
      * @return
      */
-    @ApiOperation(value = "暂存/提交")
+    @ApiOperation(value = "入库申请-暂存/提交")
     @RequestMapping(value = "/apply_save", method = RequestMethod.POST)
     public Result taskApplySave(@RequestBody ExamTaskDetail examTaskDetail) throws IOException {
         boolean isSuccess = examTaskService.saveExamTaskDetail(examTaskDetail);
@@ -329,19 +329,19 @@ public class ExamTaskController {
     }
 
     /**
-     * 撤回/重新申请
+     * 入库申请-撤回
      *
      * @param examTask
      * @return
      */
-    @ApiOperation(value = "撤回")
+    @ApiOperation(value = "入库申请-撤回")
     @RequestMapping(value = "/apply_status", method = RequestMethod.POST)
     public Result taskApplyStatus(@RequestBody ExamTask examTask) {
         return ResultUtil.ok(examTaskService.status(examTask));
     }
 
     /**
-     * 入库审核查询-未审核
+     * 入库审核-查询-未审核
      *
      * @param courseCode
      * @param paperNumber
@@ -356,7 +356,7 @@ public class ExamTaskController {
      * @param pageSize
      * @return
      */
-    @ApiOperation(value = "入库审核查询-未审核")
+    @ApiOperation(value = "入库审核-查询-未审核")
     @RequestMapping(value = "/review_list_unaudited", method = RequestMethod.POST)
     public Result taskReviewListUnaudited(@RequestParam(value = "courseCode", required = false) String courseCode,
                                           @RequestParam(value = "paperNumber", required = false) String paperNumber,
@@ -373,7 +373,7 @@ public class ExamTaskController {
     }
 
     /**
-     * 入库审核查询-未审核
+     * 入库审核-查询-未审核
      *
      * @param courseCode
      * @param paperNumber
@@ -388,7 +388,7 @@ public class ExamTaskController {
      * @param pageSize
      * @return
      */
-    @ApiOperation(value = "入库审核查询-已审核")
+    @ApiOperation(value = "入库审核-查询-已审核")
     @RequestMapping(value = "/review_list_audited", method = RequestMethod.POST)
     public Result taskReviewListAudited(@RequestParam(value = "reviewStatus", required = false) String
                                                 reviewStatus,
@@ -433,16 +433,39 @@ public class ExamTaskController {
     }
 
     /**
-     * 批量审核
+     * 入库审核-批量审核
      *
      * @param taskReviewLog
      * @return
      */
-    @ApiOperation(value = "批量审核")
+    @ApiOperation(value = "入库审核-批量审核")
     @RequestMapping(value = "/review_save_batch", method = RequestMethod.POST)
     public Result taskReviewSaveBatch(@RequestBody ExamTaskReviewLog taskReviewLog) throws IOException {
         List<Long> examTaskIdList = Arrays.asList(taskReviewLog.getExamTaskIds());
-        SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
+        if(!CollectionUtils.isEmpty(examTaskIdList)){
+            for (Long examTaskId : examTaskIdList) {
+                ExamTask examTask = examTaskService.getById(examTaskId);
+                Task task = taskService.createTaskQuery().processInstanceId(String.valueOf(examTask.getFlowId())).singleResult();
+                Map<String, Object> map = new HashMap<>();
+                map.computeIfAbsent(SystemConstant.FLOW_TASK_ID, v -> task.getId());
+                map.computeIfAbsent(SystemConstant.APPROVE_OPERATION, v -> FlowApprovePassEnum.PASS);
+                Map<String, Object> objectMap = activitiService.taskApprove(map);
+                if (Objects.nonNull(objectMap)) {
+                    TFFlowApprove tfFlowApprove = (TFFlowApprove) objectMap.get("tfFlowApprove");
+                    //审核通过，生成pdf
+                    if (Objects.nonNull(tfFlowApprove) && FlowGdykdxApproveSetupEnum.FINISH.getSetup() == tfFlowApprove.getSetup()) {
+//                        ExamTask examTask = (ExamTask) objectMap.get("examTask");
+                        SysUser sysUser = (SysUser) objectMap.get("sysUser");
+                        try {
+                            printCommonService.checkData(examTask.getSchoolId(), examTask.getCourseCode(), examTask.getPaperNumber(), sysUser);
+                        } catch (IOException e) {
+                            throw ExceptionResultEnum.ERROR.exception("生成pdf失败");
+                        }
+                    }
+                }
+            }
+        }
+        /*SysUser sysUser = (SysUser) ServletUtil.getRequestUser();
         boolean isSuccess = examTaskService.taskReviewSaveBatch(taskReviewLog);
         if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.PASS.name())) {
             // 发送审核通过短信通知
@@ -450,8 +473,8 @@ public class ExamTaskController {
         } else if (isSuccess && taskReviewLog.getReviewStatus().name().equals(ReviewStatusEnum.NOT_PASS.name())) {
             // 发送审核不通过短信通知
             basicMessageService.noticeOfExamTaskAudit(examTaskIdList, MessageEnum.NOTICE_OF_AUDIT_NOT_PASS, sysUser);
-        }
-        return ResultUtil.ok(isSuccess);
+        }*/
+        return ResultUtil.ok();
     }
 
     @ApiOperation(value = "导出审核样本")

teachcloud-common/src/main/java/com/qmth/teachcloud/common/service/impl/SysRoleServiceImpl.java

@@ -239,16 +239,16 @@ public class SysRoleServiceImpl extends ServiceImpl<SysRoleMapper, SysRole> impl
 
     @Override
     public List<SysRole> listToUser() {
-        Long schoolId = null;
-        try {
-            Object object = ServletUtil.getRequestHeaderSchoolId();
-            schoolId = Long.valueOf(object.toString());
-        } catch (Exception e) {
+        Object object = ServletUtil.getRequestHeaderSchoolIdByNotVaild();
 
-        }
         QueryWrapper<SysRole> queryWrapper = new QueryWrapper<>();
-        Long finalSchoolId = schoolId;
-        queryWrapper.lambda().eq(SysRole::getEnable, true).and(e -> e.eq(SysRole::getSchoolId, finalSchoolId));
+        queryWrapper.lambda().eq(SysRole::getEnable, true);
+        if (Objects.isNull(object)) {
+            queryWrapper.lambda().isNull(SysRole::getSchoolId);
+        } else {
+            Long schoolId = Long.valueOf(object.toString());
+            queryWrapper.lambda().eq(SysRole::getSchoolId, schoolId);
+        }
         return this.list(queryWrapper);
     }
 }