联考版-v3.1.0-测试bug修改（定档规则修改）

stmms-ms-admin/src/main/java/cn/com/qmth/stmms/ms/admin/api/ParamApi.java

@@ -168,6 +168,11 @@ public class ParamApi {
             }
         }
 
+        // 开启自动打回，打回累计误差必填
+        if(autoCallback == 1 && cumulativeError == null){
+            throw new RuntimeException("系统自动打回已开启，【打回累计误差】必填");
+        }
+
         oldRoughLevelConfig.setDeviation(deviation);
         oldRoughLevelConfig.setAutoCallback(autoCallback);
         oldRoughLevelConfig.setCumulativeError(cumulativeError);
@@ -239,6 +244,12 @@ public class ParamApi {
                 throw new RuntimeException("评卷工作已有正评数据，不能修改【是否开启去高去低再加权评卷】参数");
             }
         }
+
+        // 开启自动打回，打回累计误差必填
+        if(autoCallback == 1 && cumulativeError == null){
+            throw new RuntimeException("系统自动打回已开启，【打回累计误差】必填");
+        }
+
         if (oldLevelConfig.getRoughLevelEnable() == 1) {
             List<MarkStage> markStageList1 = Arrays.asList(new MarkStage[]{MarkStage.ROUGH_LEVEL});
             List<MarkSubject> subjectList = markSubjectRepo.findByWorkIdAndTestAndStageIn(workId, TrialEnum.DEFAULT.getId(), markStageList1);

stmms-ms-admin/src/main/java/cn/com/qmth/stmms/ms/admin/exporter/UserExporter.java

@@ -14,12 +14,14 @@ import cn.com.qmth.stmms.ms.core.repository.MarkUserRepo;
 import cn.com.qmth.stmms.ms.core.repository.StudentRepo;
 import cn.com.qmth.stmms.ms.core.vo.Subject;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.util.StringUtils;
 import org.springframework.web.bind.annotation.*;
 
 import javax.annotation.Resource;
 import javax.servlet.http.HttpServletResponse;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 /**
@@ -48,9 +50,9 @@ public class UserExporter {
     @RequestMapping(method = RequestMethod.GET)
     public void export(@RequestParam Long workId, @RequestParam(required = false) Subject subject, HttpServletResponse response) {
         List<MarkUserDTO> markUserDTOs = new ArrayList<>();
-        Stream<MarkUser> markUserStream = markUserRepo.findByWorkId(workId).stream();
+        List<MarkUser> markUserStream = markUserRepo.findByWorkId(workId);
         if (subject != null) {
-            markUserStream = markUserStream.filter(u -> u.getSubject().name() == subject.name() && (Role.MARKER.equals(u.getRole()) || Role.MARK_LEADER.equals(u.getRole())));
+            markUserStream = markUserStream.stream().filter(u -> u.getSubject() != null && u.getSubject().equals(subject) && (Role.MARKER.equals(u.getRole()) || Role.MARK_LEADER.equals(u.getRole()))).collect(Collectors.toList());
         }
         markUserStream.forEach(u -> {
             markUserDTOs.add(markUserAssembler.toDTO(u));

stmms-ms-admin/src/main/java/cn/com/qmth/stmms/ms/admin/service/TrialService.java

@@ -150,7 +150,13 @@ public class TrialService {
 
         for (Paper paper : paperList) {
             // 标准卷不清除档位
-            paper.setBatchNo(null);
+            if (MarkStage.ROUGH_LEVEL.equals(markSubject.getStage())) {
+                paper.setRoughBatchNo(null);
+            } else if (MarkStage.LEVEL.equals(markSubject.getStage())) {
+                paper.setBatchNo(null);
+            }
+            // 科组长标记清除
+            paper.setMarkByLeader(false);
             // 打回标记清除
             paper.setRejected(false);
             paper.setRejectedByLeader(false);

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/api/MarkTaskApi.java

@@ -3,12 +3,10 @@ package cn.com.qmth.stmms.ms.marking.api;
 import cn.com.qmth.stmms.ms.commons.lock.LockService;
 import cn.com.qmth.stmms.ms.commons.utils.ServletUtil;
 import cn.com.qmth.stmms.ms.commons.web.PageableDTO;
-import cn.com.qmth.stmms.ms.core.cache.ParamCache;
 import cn.com.qmth.stmms.ms.core.domain.Level;
 import cn.com.qmth.stmms.ms.core.domain.MarkStage;
 import cn.com.qmth.stmms.ms.core.domain.MarkSubject;
 import cn.com.qmth.stmms.ms.core.domain.Paper;
-import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskRoughLevel;
 import cn.com.qmth.stmms.ms.core.domain.user.MarkerGroupLeader;
 import cn.com.qmth.stmms.ms.core.repository.LevelRepo;
 import cn.com.qmth.stmms.ms.core.repository.MarkSubjectRepo;
@@ -249,7 +247,6 @@ public class MarkTaskApi {
     public List<PaperDTO> reviewPaper(@RequestParam Long workId,
                                       @RequestParam Subject subject,
                                       @RequestParam Long questionId) {
-
         MarkSubject markSubject = markSubjectRepo.findOne(workId + "-" + subject.name());
         Long markerId = ServletUtil.getUserId();
         List<MarkerGroupLeader> markerGroupLeaders = markerGroupLeaderService.listByWorkIdAndSubjectAndStageAndMarkLeaderId(markSubject.getWorkId(), markSubject, markerId);
@@ -277,7 +274,11 @@ public class MarkTaskApi {
 
             predicates.add(builder.equal(root.get("markByLeader"), true));
             List<Predicate> list = new ArrayList<>();
-            list.add(builder.equal(root.get("isSample"), true));
+            if (MarkStage.ROUGH_LEVEL.equals(markSubject.getStage())) {
+                list.add(builder.equal(root.get("isRoughSample"), true));
+            } else if (MarkStage.LEVEL.equals(markSubject.getStage())) {
+                list.add(builder.equal(root.get("isSample"), true));
+            }
             list.add(builder.equal(root.get("isOneClick"), true));
             list.add(builder.equal(root.get("isRejectedByLeader"), true));
             Predicate Pre_And = builder.and(predicates.toArray(new Predicate[predicates.size()]));

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/service/DetermineLevelService.java

@@ -3,16 +3,14 @@ package cn.com.qmth.stmms.ms.marking.service;
 import cn.com.qmth.stmms.ms.core.cache.ParamCache;
 import cn.com.qmth.stmms.ms.core.domain.Level;
 import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskLevel;
+import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskRoughLevel;
 import cn.com.qmth.stmms.ms.core.domain.user.MarkUser;
-import cn.com.qmth.stmms.ms.core.repository.LevelRepo;
 import cn.com.qmth.stmms.ms.core.repository.MarkUserRepo;
+import cn.com.qmth.stmms.ms.marking.service.arbitration.ArbitrationService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Collectors;
 import java.util.stream.DoubleStream;
 import java.util.stream.Stream;
@@ -26,17 +24,23 @@ public class DetermineLevelService {
 
     public enum DeterType {
         /**
-         * 多数
+         * 过半定档
          */
         MAJORITY,
         /**
          * 权重
          */
-        WEIGHT
+        WEIGHT,
+        /**
+         * 仲裁
+         */
+        ARBITRATE,
+        /**
+         * 打回
+         */
+        REJECT
     }
 
-    @Autowired
-    private LevelRepo levelRepo;
     @Autowired
     private MarkUserRepo markUserRepo;
 
@@ -50,18 +54,20 @@ public class DetermineLevelService {
         // 是否过半定档（1：是）
         boolean majority = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(String.valueOf(workId))).getMajority()).orElse(1) == 1;
         DeterResult majorityResult = null;
-        DeterResult weightResult = null;
+        DeterResult weightResult;
+        // 开启过半定档
         if (majority) {
             MarkTaskLevel[] tasks = markTasks.toArray(new MarkTaskLevel[0]);
             majorityResult = calcMajority(tasks);
         }
-        weightResult = calcWeight(workId, levels, markTasks);
-
+        // 有过半档位
         if (majorityResult != null) {
             // 是否取优（过半定档和权重，取最优值）
             boolean takeBest = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(String.valueOf(workId))).getTakeBest()).orElse(1) == 1;
             if (takeBest) {
                 Map<String, Integer> levelMap = levels.stream().collect(Collectors.toMap(Level::getCode, Level::getLevelValue));
+
+                weightResult = calcWeight(workId, levels, markTasks);
                 // 取优
                 int majorityLevelValue = levelMap.get(majorityResult.getResult());
                 int weightLevelValue = levelMap.get(weightResult.getResult());
@@ -74,8 +80,29 @@ public class DetermineLevelService {
             } else {
                 return majorityResult;
             }
-        } else {
-            return weightResult;
+        }
+        // 无过半档位或者未开启过半定档
+        else {
+            // 仲裁档位差
+            int deviation = ParamCache.levelConfigMap.get(String.valueOf(workId)).getDeviation();
+            // 超过仲裁档位差
+            Set<Integer> sources = markTasks.stream().map(MarkTaskLevel::getLevelValue).collect(Collectors.toSet());
+            if (ArbitrationService.overDeviation(deviation, sources)) {
+                boolean autoCallBack = ParamCache.levelConfigMap.get(String.valueOf(workId)).getAutoCallback() == 1;
+                // 开启自动打回
+                if (autoCallBack) {
+                    int cumulateError = ParamCache.levelConfigMap.get(String.valueOf(workId)).getCumulativeError();
+                    List<String> markerIds = ArbitrationService.calcCumulateLevel(cumulateError, markTasks);
+                    // 不是所有评卷员累计误差都大于累计误差值
+                    if (markerIds.size() != markTasks.size()) {
+                        return new DeterResult(null, DeterType.REJECT, markerIds);
+                    }
+                }
+                // 打回科组长
+                return new DeterResult(null, DeterType.ARBITRATE);
+            } else {
+                return calcWeight(workId, levels, markTasks);
+            }
         }
     }
 
@@ -99,10 +126,11 @@ public class DetermineLevelService {
         double[] weights = new double[tasks.length];
         for (int i = 0; i < tasks.length; i++) {
             String levelResult = tasks[i].getResult();
-            Level level = levels.stream().filter(m -> m.getCode().equals(levelResult)).findFirst().orElse(null);
-            if (level == null) {
+            Optional<Level> levelOptional = levels.stream().filter(m -> m.getCode().equals(levelResult)).findFirst();
+            if (!levelOptional.isPresent()) {
                 throw new RuntimeException("无此档位");
             }
+            Level level = levelOptional.get();
             MarkUser marker = markUserRepo.findOne(tasks[i].getMarkerId());
             double markerWeight = marker.getWeight();
             values[i] = level.getWeight() * markerWeight;
@@ -110,7 +138,10 @@ public class DetermineLevelService {
         }
         int avg = (int) Math.round(DoubleStream.of(values).sum() / DoubleStream.of(weights).sum());
         Optional<Level> levelOptional = levels.stream().filter(o -> o.getMaxScore() >= avg && o.getMinScore() <= avg).findFirst();
-        Level level = levelOptional.orElse(null);
+        Level level = null;
+        if (levelOptional.isPresent()) {
+            level = levelOptional.get();
+        }
         if (level == null) {
             levels = levels.stream().sorted(Comparator.comparing(Level::getMaxScore).reversed()).collect(Collectors.toList());
             if (avg > levels.get(0).getMaxScore()) {
@@ -136,7 +167,7 @@ public class DetermineLevelService {
                 .collect(Collectors.groupingBy(MarkTaskLevel::getResult, Collectors.counting()))
                 .entrySet()
                 .stream()
-                .max(Comparator.comparing(Map.Entry::getValue));
+                .max(Map.Entry.comparingByValue());
         if (optional.isPresent()) {
             Map.Entry<String, Long> entry = optional.get();
             if (entry.getValue() > tasks.length / 2) {
@@ -150,12 +181,19 @@ public class DetermineLevelService {
 class DeterResult {
     private String result;
     private DetermineLevelService.DeterType deterType;
+    private List<String> rejectTasks;
 
     public DeterResult(String result, DetermineLevelService.DeterType deterType) {
         this.result = result;
         this.deterType = deterType;
     }
 
+    public DeterResult(String result, DetermineLevelService.DeterType deterType, List<String> rejectTasks) {
+        this.result = result;
+        this.deterType = deterType;
+        this.rejectTasks = rejectTasks;
+    }
+
     public String getResult() {
         return result;
     }
@@ -171,4 +209,12 @@ class DeterResult {
     public void setDeterType(DetermineLevelService.DeterType deterType) {
         this.deterType = deterType;
     }
+
+    public List<String> getRejectTasks() {
+        return rejectTasks;
+    }
+
+    public void setRejectTasks(List<String> rejectTasks) {
+        this.rejectTasks = rejectTasks;
+    }
 }

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/service/DetermineRoughLevelService.java

@@ -8,6 +8,7 @@ import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskRoughLevel;
 import cn.com.qmth.stmms.ms.core.domain.user.MarkUser;
 import cn.com.qmth.stmms.ms.core.repository.LevelRepo;
 import cn.com.qmth.stmms.ms.core.repository.MarkUserRepo;
+import cn.com.qmth.stmms.ms.marking.service.arbitration.ArbitrationService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
@@ -31,7 +32,15 @@ public class DetermineRoughLevelService {
         /**
          * 权重
          */
-        WEIGHT
+        WEIGHT,
+        /**
+         * 仲裁
+         */
+        ARBITRATE,
+        /**
+         * 打回
+         */
+        REJECT
     }
 
     @Autowired
@@ -46,20 +55,21 @@ public class DetermineRoughLevelService {
     public RoughDeterResult determine(Long workId, List<Level> levels, List<MarkTaskRoughLevel> markTasks) {
         List<RoughLevel> roughLevels = parseRoughLevels(levels);
         // 是否过半定档（1：是）
-        boolean majority = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(String.valueOf(workId))).getMajority()).orElse(1) == 1;
+        boolean majority = Optional.ofNullable(ParamCache.roughLevelConfigMap.get(String.valueOf(String.valueOf(workId))).getMajority()).orElse(1) == 1;
         RoughDeterResult majorityResult = null;
-        RoughDeterResult weightResult = null;
+        RoughDeterResult weightResult;
         if (majority) {
             MarkTaskRoughLevel[] tasks = markTasks.toArray(new MarkTaskRoughLevel[0]);
             majorityResult = calcMajority(tasks);
         }
-        weightResult = calcWeight(workId, roughLevels, markTasks);
 
         if (majorityResult != null) {
             // 是否取优（过半定档和权重，取最优值）
-            boolean takeBest = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(String.valueOf(workId))).getTakeBest()).orElse(1) == 1;
+            boolean takeBest = Optional.ofNullable(ParamCache.roughLevelConfigMap.get(String.valueOf(String.valueOf(workId))).getTakeBest()).orElse(1) == 1;
             if (takeBest) {
                 Map<String, String> levelMap = roughLevels.stream().collect(Collectors.toMap(RoughLevel::getRoughCode, RoughLevel::getRoughCode));
+
+                weightResult = calcWeight(workId, roughLevels, markTasks);
                 // 取优
                 int majorityLevelValue = Integer.parseInt(levelMap.get(majorityResult.getResult()));
                 int weightLevelValue = Integer.parseInt(levelMap.get(weightResult.getResult()));
@@ -72,8 +82,29 @@ public class DetermineRoughLevelService {
             } else {
                 return majorityResult;
             }
-        } else {
-            return weightResult;
+        }
+        // 无过半档位或者未开启过半定档
+        else {
+            // 仲裁档位差
+            int deviation = ParamCache.roughLevelConfigMap.get(String.valueOf(workId)).getDeviation();
+            // 超过仲裁档位差
+            Set<Integer> sources = markTasks.stream().map(MarkTaskRoughLevel::getLevelValue).collect(Collectors.toSet());
+            if (ArbitrationService.overDeviation(deviation, sources)) {
+                boolean autoCallBack = ParamCache.roughLevelConfigMap.get(String.valueOf(workId)).getAutoCallback() == 1;
+                // 开启自动打回
+                if (autoCallBack) {
+                    int cumulateError = ParamCache.roughLevelConfigMap.get(String.valueOf(workId)).getCumulativeError();
+                    List<String> markerIds = ArbitrationService.calcCumulateRoughLevel(cumulateError, markTasks);
+                    // 不是所有评卷员累计误差都大于累计误差值
+                    if (markerIds.size() != markTasks.size()) {
+                        return new RoughDeterResult(null, DeterType.REJECT, markerIds);
+                    }
+                }
+                // 打回科组长
+                return new RoughDeterResult(null, DeterType.ARBITRATE);
+            } else {
+                return calcWeight(workId, roughLevels, markTasks);
+            }
         }
     }
 
@@ -84,7 +115,7 @@ public class DetermineRoughLevelService {
      */
     private RoughDeterResult calcWeight(Long workId, List<RoughLevel> roughLevels, List<MarkTaskRoughLevel> markTasks) {
         // 是否开启去高去低再加权评卷（1：是， 0：否，默认0）
-        boolean removeHighAndLow = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(String.valueOf(workId))).getRemoveHighAndLow()).orElse(0) == 1;
+        boolean removeHighAndLow = Optional.ofNullable(ParamCache.roughLevelConfigMap.get(String.valueOf(String.valueOf(workId))).getRemoveHighAndLow()).orElse(0) == 1;
         if (removeHighAndLow && markTasks.size() > 2) {
             markTasks.sort((Comparator.comparing(MarkTaskRoughLevel::getResult)));
             markTasks.remove(0);//去掉最大值
@@ -168,12 +199,19 @@ public class DetermineRoughLevelService {
 class RoughDeterResult {
     private String result;
     private DetermineRoughLevelService.DeterType deterType;
+    private List<String> rejectTasks;
 
     public RoughDeterResult(String result, DetermineRoughLevelService.DeterType deterType) {
         this.result = result;
         this.deterType = deterType;
     }
 
+    public RoughDeterResult(String result, DetermineRoughLevelService.DeterType deterType, List<String> rejectTasks) {
+        this.result = result;
+        this.deterType = deterType;
+        this.rejectTasks = rejectTasks;
+    }
+
     public String getResult() {
         return result;
     }
@@ -189,4 +227,12 @@ class RoughDeterResult {
     public void setDeterType(DetermineRoughLevelService.DeterType deterType) {
         this.deterType = deterType;
     }
+
+    public List<String> getRejectTasks() {
+        return rejectTasks;
+    }
+
+    public void setRejectTasks(List<String> rejectTasks) {
+        this.rejectTasks = rejectTasks;
+    }
 }

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/service/MarkingLevelService.java

@@ -2,14 +2,13 @@ package cn.com.qmth.stmms.ms.marking.service;
 
 import cn.com.qmth.stmms.ms.commons.constant.ArbitrateCallback;
 import cn.com.qmth.stmms.ms.commons.constant.ArbitrateResult;
-import cn.com.qmth.stmms.ms.core.cache.ParamCache;
 import cn.com.qmth.stmms.ms.core.domain.*;
 import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskLevel;
 import cn.com.qmth.stmms.ms.core.domain.user.MarkUser;
 import cn.com.qmth.stmms.ms.core.domain.user.Role;
 import cn.com.qmth.stmms.ms.core.repository.*;
-import cn.com.qmth.stmms.ms.marking.service.arbitration.ArbitrationService;
 import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -74,6 +73,9 @@ public class MarkingLevelService {
     @Autowired
     AssignTaskService assignTaskService;
 
+    @Resource
+    MarkingLevelService markingLevelService;
+
     /**
      * 提交分档。如果每个评卷都提交了，则进行仲裁判定，如果没有触发仲裁就定档
      *
@@ -112,31 +114,24 @@ public class MarkingLevelService {
         if (leftCount == 0) {
             //定档
             DeterResult determine = determineLevelService.determine(markTask.getWorkId(), levels, markTasks);
-            if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult())) {
-                markTask.setDateMineResult(determine.getResult());
-            }
-            //1.过半定档
-            if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult()) && determine.getDeterType() == DetermineLevelService.DeterType.MAJORITY) {
+            // 过半定档或者权重定档
+            if (determine.getDeterType() == DetermineLevelService.DeterType.MAJORITY || determine.getDeterType() == DetermineLevelService.DeterType.WEIGHT) {
                 paper.determineLevel(determine.getResult());
                 paper.setMarkedLogic(false);
                 //档位落差值日志
                 levelsLog(markTasks, paper);
-            } else {
-                int[] values = markTasks.stream().mapToInt(MarkTaskLevel::getLevelValue).toArray();
-                Integer deviation = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(markTask.getWorkId())).getDeviation()).orElse(3);
-                boolean result = ArbitrationService.arbitrate(deviation, values);
-                //2.最大落差超过仲裁档位,则仲裁打回
-                if (result) {
-                    //仲裁
-                    paper.arbitrate();
-                }
-                //3.最大落差未超过仲裁档位,则权重计算定档
-                else if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult()) && determine.getDeterType() == DetermineLevelService.DeterType.WEIGHT) {
-                    paper.determineLevel(determine.getResult());
-                    paper.setMarkedLogic(true);
-                    //档位落差值日志
-                    levelsLog(markTasks, paper);
-                }
+            }
+            //仲裁
+            else if (determine.getDeterType() == DetermineLevelService.DeterType.ARBITRATE) {
+                paper.arbitrate();
+            }
+            // 打回
+            else if (determine.getDeterType() == DetermineLevelService.DeterType.REJECT) {
+                paper.setOneClick(false);
+                paper.setRejectedByLeader(true);
+                //需要打回的评卷员
+                String ranges = String.join(",", determine.getRejectTasks());
+                markingLevelService.reject(paper, null, ranges);
             }
             //改档后重新分档，状态改为false
             paper.setShift(false);
@@ -268,7 +263,6 @@ public class MarkingLevelService {
      * @param paper
      * @param redoLevel 建议重评档位
      * @param ranges
-     * @param stage
      */
     @Transactional
     public Paper reject(Paper paper, String redoLevel, String ranges) {
@@ -294,7 +288,7 @@ public class MarkingLevelService {
                 String operResult = "-";
                 for (String r : range) {
                     // 建议的档位与其中评委所评档位相同时就不打回给此评委
-                    if (Objects.equals(String.valueOf(markTask.getMarkerId()), r) && !redoLevel.equals(markTask.getResult())) {
+                    if (Objects.equals(String.valueOf(markTask.getMarkerId()), r) && (StringUtils.isBlank(redoLevel) || !redoLevel.equals(markTask.getResult()))) {
                         markTask.setRejected(true);
                         markTask.setOriginLevel(markTask.getResult());
                         markTask.setResult(null);

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/service/MarkingRoughLevelService.java

@@ -2,14 +2,13 @@ package cn.com.qmth.stmms.ms.marking.service;
 
 import cn.com.qmth.stmms.ms.commons.constant.ArbitrateCallback;
 import cn.com.qmth.stmms.ms.commons.constant.ArbitrateResult;
-import cn.com.qmth.stmms.ms.core.cache.ParamCache;
 import cn.com.qmth.stmms.ms.core.domain.*;
 import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskRoughLevel;
 import cn.com.qmth.stmms.ms.core.domain.user.MarkUser;
 import cn.com.qmth.stmms.ms.core.domain.user.Role;
 import cn.com.qmth.stmms.ms.core.repository.*;
-import cn.com.qmth.stmms.ms.marking.service.arbitration.ArbitrationService;
 import com.alibaba.fastjson.JSONObject;
+import org.apache.commons.lang.StringUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -77,6 +76,9 @@ public class MarkingRoughLevelService {
     @Autowired
     AssignTaskService assignTaskService;
 
+    @Resource
+    MarkingRoughLevelService markingRoughLevelService;
+
     /**
      * 提交分档。如果每个评卷都提交了，则进行仲裁判定，如果没有触发仲裁就定档
      *
@@ -112,31 +114,24 @@ public class MarkingRoughLevelService {
             List<Level> levels = levelRepo.findByWorkId(paper.getWorkId());
             //定档
             RoughDeterResult determine = determineRoughLevelService.determine(markTask.getWorkId(), levels, markTasks);
-            if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult())) {
-                markTask.setDateMineResult(determine.getResult());
-            }
-            //1.过半定档
-            if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult()) && determine.getDeterType() == DetermineRoughLevelService.DeterType.MAJORITY) {
+            // 过半定档或者权重定档
+            if (determine.getDeterType() == DetermineRoughLevelService.DeterType.MAJORITY || determine.getDeterType() == DetermineRoughLevelService.DeterType.WEIGHT) {
                 paper.determineRoughLevel(determine.getResult());
                 paper.setMarkedLogic(false);
                 //档位落差值日志
                 levelsLog(markTasks, paper);
-            } else {
-                int[] values = markTasks.stream().mapToInt(MarkTaskRoughLevel::getLevelValue).toArray();
-                Integer deviation = Optional.ofNullable(ParamCache.levelConfigMap.get(String.valueOf(markTask.getWorkId())).getDeviation()).orElse(3);
-                boolean result = ArbitrationService.arbitrate(deviation, values);
-                //2.最大落差超过仲裁档位,则仲裁打回
-                if (result) {
-                    //仲裁
-                    paper.arbitrate();
-                }
-                //3.最大落差未超过仲裁档位,则权重计算定档
-                else if (Objects.nonNull(determine) && Objects.nonNull(determine.getResult()) && determine.getDeterType() == DetermineRoughLevelService.DeterType.WEIGHT) {
-                    paper.determineRoughLevel(determine.getResult());
-                    paper.setMarkedLogic(true);
-                    //档位落差值日志
-                    levelsLog(markTasks, paper);
-                }
+            }
+            //仲裁
+            else if (determine.getDeterType() == DetermineRoughLevelService.DeterType.ARBITRATE) {
+                paper.arbitrate();
+            }
+            // 打回
+            else if (determine.getDeterType() == DetermineRoughLevelService.DeterType.REJECT) {
+                paper.setOneClick(false);
+                paper.setRejectedByLeader(true);
+                //需要打回的评卷员
+                String ranges = String.join(",", determine.getRejectTasks());
+                markingRoughLevelService.reject(paper, null, ranges);
             }
             //改档后重新分档，状态改为false
             paper.setShift(false);
@@ -290,7 +285,7 @@ public class MarkingRoughLevelService {
                 String operResult = "-";
                 for (String r : range) {
                     // 建议的档位与其中评委所评档位相同时就不打回给此评委
-                    if (Objects.equals(String.valueOf(markTask.getMarkerId()), r) && !redoLevel.equals(markTask.getResult())) {
+                    if (Objects.equals(String.valueOf(markTask.getMarkerId()), r) && (StringUtils.isBlank(redoLevel) || !redoLevel.equals(markTask.getResult()))) {
                         markTask.setRejected(true);
                         markTask.setOriginLevel(markTask.getResult());
                         markTask.setResult(null);

stmms-ms-marking/src/main/java/cn/com/qmth/stmms/ms/marking/service/arbitration/ArbitrationService.java

@@ -1,7 +1,10 @@
 package cn.com.qmth.stmms.ms.marking.service.arbitration;
 
 
-import java.util.OptionalInt;
+import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskLevel;
+import cn.com.qmth.stmms.ms.core.domain.task.MarkTaskRoughLevel;
+
+import java.util.*;
 import java.util.stream.IntStream;
 
 /**
@@ -15,7 +18,6 @@ public class ArbitrationService {
      *
      * @param deviation 误差
      * @param sources
-     * @return
      */
     public static boolean arbitrate(int deviation, int... sources) {
 
@@ -34,4 +36,61 @@ public class ArbitrationService {
         }
         return false;
     }
+
+
+    /**
+     * 计算是否超过仲裁档位差
+     *
+     * @param sources 档位
+     * @return boolean true超过
+     */
+    public static boolean overDeviation(int deviation, Set<Integer> sources) {
+        Optional<Integer> maxOptional = sources.stream().max(Comparator.comparing(String::valueOf));
+        Optional<Integer> minOptional = sources.stream().min(Comparator.comparing(String::valueOf));
+        int max = 0;
+        if (maxOptional.isPresent()) {
+            max = maxOptional.get();
+        }
+        int min = 0;
+        if (minOptional.isPresent()) {
+            min = minOptional.get();
+        }
+        int diff = Math.abs(max - min);
+        return diff >= deviation;
+    }
+
+    /**
+     * 计算累计档位差
+     *
+     * @param cumulateError 打回累计误差
+     * @param markTasks     评卷任务
+     * @return List<MarkTaskLevel>
+     */
+    public static List<String> calcCumulateRoughLevel(int cumulateError, List<MarkTaskRoughLevel> markTasks) {
+        List<String> markerIds = new ArrayList<>();
+        for (MarkTaskRoughLevel markTask : markTasks) {
+            int cumulate = 0;
+            for (MarkTaskRoughLevel task : markTasks) {
+                cumulate += Math.abs(markTask.getLevelValue() - task.getLevelValue());
+            }
+            if (cumulate >= cumulateError) {
+                markerIds.add(String.valueOf(markTask.getMarkerId()));
+            }
+        }
+        return markerIds;
+    }
+
+    public static List<String> calcCumulateLevel(int cumulateError, List<MarkTaskLevel> markTasks) {
+        List<String> markerIds = new ArrayList<>();
+        for (MarkTaskLevel markTask : markTasks) {
+            int cumulate = 0;
+            for (MarkTaskLevel task : markTasks) {
+                cumulate += Math.abs(markTask.getLevelValue() - task.getLevelValue());
+            }
+            if (cumulate >= cumulateError) {
+                markerIds.add(String.valueOf(markTask.getMarkerId()));
+            }
+        }
+        return markerIds;
+    }
 }