机构版-3.0.0-bug修复(定档规则修改)

stmms-ms-accesscontrol/src/main/java/cn/com/qmth/stmms/ms/accesscontrol/config/AccessConfig.java

@@ -11,14 +11,13 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter
  * Created by zhengmin on 2017/3/2.
  */
 @Configuration
-//@Profile(value = "dev")
 public class AccessConfig extends WebMvcConfigurerAdapter {
 
     @Override
     public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/**").allowedOrigins("*").allowCredentials(false)
                 .allowedMethods("PUT", "DELETE", "GET", "POST", "PATCH").allowedHeaders("Cache-Control", "Pragma",
-                "Origin", "Authorization", "Content-Type", "X-Requested-With")
+                        "Origin", "Authorization", "Content-Type", "X-Requested-With")
                 .maxAge(9999999999999999L);
         // .exposedHeaders("header1", "header2")
     }
@@ -30,9 +29,9 @@ public class AccessConfig extends WebMvcConfigurerAdapter {
 
     @Override
     public void addInterceptors(InterceptorRegistry registry) {
-        registry.addInterceptor(loginInterceptor()).addPathPatterns("/api/**").excludePathPatterns("/api/admin/users/login","/api/login","/api/logout","/api/*/password",
+        registry.addInterceptor(loginInterceptor()).addPathPatterns("/api/**").excludePathPatterns("/api/admin/users/login", "/api/login", "/api/logout", "/api/*/password",
                 "/api/user/login", "/api/user/getClientUser", "/api/exam/students", "/api/upload/student/*", "/api/file/image/**", "/api/marklog/saveCollectLog",
-                "/api/file/ms-slice/**", "/api/subject/collect-config", "/api/file/ms-sheet/**", "/api/oss/**", "/api/exam/listStudents/*", "/api/exam/getStudent/*","/api/level/*",
-                "/api/file/image/getExportData","/api/file/image/exportScorePicturesFromCollect","/api/admin/works","/api/score/missing/*", "/api/papers/*/*/*");
+                "/api/file/ms-slice/**", "/api/subject/collect-config", "/api/file/ms-sheet/**", "/api/oss/**", "/api/exam/listStudents/*", "/api/exam/getStudent/*", "/api/level/*",
+                "/api/file/image/getExportData", "/api/file/image/exportScorePicturesFromCollect", "/api/admin/works", "/api/score/missing/*", "/api/papers/*/*/*");
     }
 }

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

@@ -369,6 +369,23 @@ public class MakrerApi {
                 o.setFinalTotal(Math.toIntExact(finalTotal));
             }
         });
+
+        // 标记试卷（评卷员标记的和科组长标记的都统计）
+        LevelStatDTO markPaperDTO = new LevelStatDTO();
+        markPaperDTO.setId("markPaper");
+        int markPaperCount;
+        if (ParamCache.paramMap.get(marker.getWorkId()).getLevelShowAllPaper() == 1) {
+            // 评卷员和科组长标记的试卷
+            List<Long> markTaskPaperId = markTaskRepo.findByWorkIdAndQuestionIdAndMarkerIdAndStageAndIsMark(markSubject.getWorkId(), questionId,marker.getId(), markSubject.getStage(), true);
+            markPaperCount = Math.toIntExact(markTaskPaperId.stream().distinct().count());
+        } else {
+            // 评卷员标记的试卷
+            List<Long> markTaskPaperIdAll = markTaskRepo.findByWorkIdAndQuestionIdAndMarkerIdAndStageAndBatchNoAndPaperIsMark(markSubject.getWorkId(), questionId, marker.getId(), markSubject.getStage(), batchNo);
+            markPaperCount = Math.toIntExact(markTaskPaperIdAll.stream().distinct().count());
+        }
+        markPaperDTO.setCount(markPaperCount);
+        levelStatDTOs.add(markPaperDTO);
+
         Collections.sort(levelStatDTOs, (o1, o2) -> {
             if (o1.getId() == null || o2.getId() == null) {
                 return 1;

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

@@ -1,21 +1,18 @@
 package cn.com.qmth.stmms.ms.marking.service;
 
-import java.util.Comparator;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-import java.util.stream.DoubleStream;
-import java.util.stream.Stream;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.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.MarkTask;
 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.*;
+import java.util.stream.Collectors;
+import java.util.stream.DoubleStream;
+import java.util.stream.Stream;
 
 /**
  * 定档
@@ -32,11 +29,17 @@ public class DetermineLevelService {
         /**
          * 权重
          */
-        WEIGHT
+        WEIGHT,
+        /**
+         * 仲裁
+         */
+        ARBITRATE,
+        /**
+         * 打回
+         */
+        REJECT
     }
 
-    @Autowired
-    private LevelRepo levelRepo;
     @Autowired
     private MarkUserRepo markUserRepo;
 
@@ -47,17 +50,22 @@ public class DetermineLevelService {
      * @param taskBest 是否取优
      * @param tasks    任务集合
      */
-    public DeterResult determine(boolean majority, boolean taskBest, List<Level> levels, MarkTask... tasks) {
+    public DeterResult determine(Long workId, List<Level> levels, List<MarkTask> markTasks) {
+        //定档
+        boolean majority = Optional.ofNullable(ParamCache.paramMap.get(workId).getMajority()).orElse(1) == 1;
         DeterResult majorityResult = null;
         DeterResult weightResult = null;
         if (majority) {
+            MarkTask[] tasks = markTasks.toArray(new MarkTask[0]);
             majorityResult = calcMajority(tasks);
         }
-        weightResult = calcWeight(levels, tasks);
-
         if (majorityResult != null) {
-            if (taskBest) {
+            // 是否取优（过半定档和权重，取最优值）
+            boolean takeBest = Optional.ofNullable(ParamCache.paramMap.get(workId).getTakeBest()).orElse(1) == 1;
+            if (takeBest) {
                 Map<String, Integer> levelMap = levels.stream().collect(Collectors.toMap(Level::getCode, Level::getLevelValue));
+
+                weightResult = calcWeight(levels, markTasks);
                 // 取优
                 int majorityLevelValue = levelMap.get(majorityResult.getResult());
                 int weightLevelValue = levelMap.get(weightResult.getResult());
@@ -70,8 +78,29 @@ public class DetermineLevelService {
             } else {
                 return majorityResult;
             }
-        } else {
-            return weightResult;
+        }
+        // 无过半档位或者未开启过半定档
+        else {
+            // 仲裁档位差
+            int deviation = Optional.ofNullable(ParamCache.paramMap.get(workId).getDeviation()).orElse(4);
+            // 超过仲裁档位差
+            Set<Integer> sources = markTasks.stream().map(MarkTask::getLevelValue).collect(Collectors.toSet());
+            if (ArbitrationService.overDeviation(deviation, sources)) {
+                boolean autoCallBack = Optional.ofNullable(ParamCache.paramMap.get(workId).getAutoCallback()).orElse(0) == 1;
+                // 开启自动打回
+                if (autoCallBack) {
+                    int cumulateError = Optional.ofNullable(ParamCache.paramMap.get(workId).getCumulativeError()).orElse(9);
+                    List<String> markerIds = ArbitrationService.calcCumulate(cumulateError, markTasks);
+                    // 不是所有评卷员累计误差都大于累计误差值
+                    if (markerIds.size() != markTasks.size()) {
+                        return new DeterResult(null, DeterType.REJECT, markerIds);
+                    }
+                }
+                // 打回科组长
+                return new DeterResult(null, DeterType.ARBITRATE);
+            } else {
+                return calcWeight(levels, markTasks);
+            }
         }
     }
 
@@ -84,10 +113,10 @@ public class DetermineLevelService {
         //如果相同的数量大于半数，直接定档
         Stream<MarkTask> taskStream = Stream.of(tasks);
         Optional<Map.Entry<String, Long>> optional = taskStream
-                .collect(Collectors.groupingBy(i -> i.getResult().toString(), Collectors.counting()))
+                .collect(Collectors.groupingBy(MarkTask::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) {
@@ -100,15 +129,16 @@ public class DetermineLevelService {
     /**
      * 计算权重值
      *
-     * @param tasks 任务集合
+     * @param markTasks 任务集合
      */
-    private DeterResult calcWeight(List<Level> levels, MarkTask[] tasks) {
+    private DeterResult calcWeight(List<Level> levels, List<MarkTask> markTasks) {
+        MarkTask[] tasks = markTasks.toArray(new MarkTask[0]);
         //通过权重计算，平均值四舍五入
         double[] values = new double[tasks.length];
         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);
+            Level level = levels.stream().filter(m -> m.getCode().equals(levelResult)).findFirst().orElse(null);
             if (level == null) {
                 throw new RuntimeException("无此档位");
             }
@@ -137,12 +167,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;
     }
@@ -158,4 +195,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/MarkingService.java

@@ -14,6 +14,7 @@ import cn.com.qmth.stmms.ms.core.vo.Subject;
 import cn.com.qmth.stmms.ms.marking.config.MarkingConfig;
 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;
@@ -149,37 +150,25 @@ public class MarkingService {
         List<MarkTask> markTasks = markTaskRepo.findByPaperIdAndStage(paper.getId(), markTask.getStage());
         long leftCount = markTasks.stream().filter(i -> i.getResult() == null).count();
         if (leftCount == 0) {
-            MarkTask[] sources = new MarkTask[markTasks.size()];
-            //定档
-            Integer majority = Optional.ofNullable(ParamCache.paramMap.get(markTask.getWorkId()).getMajority()).orElse(1);
-            // 是否取优（过半定档和权重，取最优值）
-            Integer takeBest = Optional.ofNullable(ParamCache.paramMap.get(markTask.getWorkId()).getTakeBest()).orElse(1);
-            DeterResult determine = determineLevelService.determine(majority == 1, takeBest == 1, levels, markTasks.toArray(sources));
-            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) {
+            DeterResult determine = determineLevelService.determine(markTask.getWorkId(), levels, markTasks);
+            // 过半定档或者权重定档
+            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(MarkTask::getLevelValue).toArray();
-                Integer deviation = Optional.ofNullable(ParamCache.paramMap.get(markTask.getWorkId()).getDeviation()).orElse(3);
-                boolean result = ArbitrationService.arbitrate(deviation.intValue(), 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());
+                markingService.reject(paper, null, ranges);
             }
             //改档后重新分档，状态改为false
             paper.setShift(false);
@@ -347,7 +336,7 @@ public class MarkingService {
                 String operResult = "-";
                 Date date = new Date();
                 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,9 @@
 package cn.com.qmth.stmms.ms.marking.service.arbitration;
 
 
-import java.util.OptionalInt;
+import cn.com.qmth.stmms.ms.core.domain.task.MarkTask;
+
+import java.util.*;
 import java.util.stream.IntStream;
 
 /**
@@ -34,4 +36,46 @@ 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> calcCumulate(int cumulateError, List<MarkTask> markTasks) {
+        List<String> markerIds = new ArrayList<>();
+        for (MarkTask markTask : markTasks) {
+            int cumulate = 0;
+            for (MarkTask task : markTasks) {
+                cumulate += Math.abs(markTask.getLevelValue() - task.getLevelValue());
+            }
+            if (cumulate >= cumulateError) {
+                markerIds.add(String.valueOf(markTask.getMarkerId()));
+            }
+        }
+        return markerIds;
+    }
 }