Merge remote-tracking branch 'origin/ywx' into wn

smarking/src/main/java/com/xhkjedu/smarking/controller/report/ZhReportController.java

@@ -4,8 +4,9 @@ import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
 import com.xhkjedu.smarking.model.exam.MsSubject;
 import com.xhkjedu.smarking.model.report.reportclass.MsrClassSubjectGrade;
-import com.xhkjedu.smarking.service.report.report.MsrClassQuestionService;
-import com.xhkjedu.smarking.service.report.report.MsrStudentService;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
+import com.xhkjedu.smarking.service.report.report.*;
 import com.xhkjedu.smarking.vo.report.reportother.ExamReportParams;
 import com.xhkjedu.utils.N_Utils;
 import com.xhkjedu.utils.PageUtil;
@@ -33,6 +34,24 @@ public class ZhReportController {
     private MsrStudentService msrStudentService;
     @Resource
     private MsrClassQuestionService msrClassQuestionService;
+    @Resource
+    private MsrSubjectService msrSubjectService;
+    @Resource
+    private MsrActionService msrActionService;
+
+    /**
+     * @Description 总概览
+     * @Date 2025/1/3 14:59
+     * @Author YWX
+     * @Param [subject]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/zgl")
+    public ResultVo listSubjectForZgl(@RequestBody MsrSubject subject) {
+        N_Utils.validation(new Object[]{subject.getExamid(), "考试id", 1});
+        return new ResultVo(0, "获取成功", msrSubjectService.listSubjectForZgl(subject));
+    }
+
     /*
      * @Description 小分表-列表
      * @Date 2024/12/24 10:25:06
@@ -104,4 +123,38 @@ public class ZhReportController {
         return new ResultVo(0,"获取成功",msrClassQuestionService.listQuestionForAllObjsub(params));
     }
 
+    /**
+     * @Description 违纪优秀-班级统计
+     * @Date 2025/1/3 14:47
+     * @Author YWX
+     * @Param [action]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/wjyx_bj")
+    public ResultVo listXwBj(@RequestBody MsrStudentAction action) {
+        N_Utils.validation(new Object[]{action.getExamid(), "考试id", 1, action.getActiontype(), "类型", 1});
+        return new ResultVo(0, "获取成功", msrActionService.listXwBj(action));
+    }
+
+    /**
+     * @Description 违纪优秀-学生统计
+     * @Date 2025/1/3 14:49
+     * @Author YWX
+     * @Param [action]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/wjyx_bj")
+    public ResultVo listXwXs(@RequestBody MsrStudentAction action) {
+        N_Utils.validation(new Object[]{action.getExamid(), "考试id", 1, action.getActiontype(), "类型", 1});
+        Integer page = action.getPage();
+        if (N_Utils.isEmptyInteger(page)) {
+            return new ResultVo(0, "获取成功", msrActionService.listXwXs(action));
+        } else {
+            PageHelper.startPage(page, action.getPageSize());
+            List<Map> list = msrActionService.listXwXs(action);
+            PageResult pageResult = PageUtil.getPageResult(new PageInfo<>(list));
+            return new ResultVo(0, "获取成功", pageResult);
+        }
+    }
+
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/exam/MsClassMapper.java

@@ -53,4 +53,7 @@ public interface MsClassMapper extends TkMapper<MsClass> {
     List<MsClass> listClassByExamId(@Param("examid") Integer examid);
     //考试科目关联不安及
     List<MsClass> listClassByExamidAndSubjectid(@Param("examid") Integer examid, @Param("subjectid") String subjectid);
+
+    //获取考试关联班级数量
+    Integer getClassNumByExamId(@Param("examid") Integer examid);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportclass/MsrClassActionMapper.java

@@ -2,6 +2,7 @@ package com.xhkjedu.smarking.mapper.report.reportclass;
 
 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportclass.MsrClassAction;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
@@ -21,4 +22,7 @@ public interface MsrClassActionMapper extends TkMapper<MsrClassAction> {
 
     //违规试卷
     List<Map> listBadQuesActionByExamId(@Param("examid") Integer examid,@Param("subjectids") String subjectids);
+
+    //行为分析-班级
+    List<Map> listXwBj(@Param("action") MsrStudentAction action);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportclass/MsrClassSubjectGradeMapper.java

@@ -5,6 +5,7 @@ import com.xhkjedu.smarking.model.report.reportclass.MsrClassSubjectGrade;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 阅卷报告-班级学科四率等级分析表 Mapper 接口
@@ -16,6 +17,9 @@ public interface MsrClassSubjectGradeMapper extends TkMapper<MsrClassSubjectGrad
     //综合报告-试题汇总表-全部班级-科目情况-四率等级分析
     List<MsrClassSubjectGrade> listSubjectGrade(@Param("sg")MsrClassSubjectGrade sg);
 
-    //综合报告-班级堆积-全科及格率分析
+    //综合报告-班级对比-全科及格率分析
     List<MsrClassSubjectGrade> listSubjectGradeForQk(@Param("examid") Integer examid,@Param("reportcode") String reportcode);
+
+    //综合报告-整体四率分析
+    List<Map<String,Object>> getZfScoreRate(@Param("examid") Integer examid);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportstu/MsrStudentActionMapper.java

@@ -2,6 +2,10 @@ package com.xhkjedu.smarking.mapper.report.reportstu;
 
 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 考试报告学生违纪优秀分析表 Mapper 接口
@@ -9,4 +13,6 @@ import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
  * @Date 2025-01-03
  */
 public interface MsrStudentActionMapper extends TkMapper<MsrStudentAction> {
+    //行为分析-学生
+    List<Map> listXwBj(@Param("action") MsrStudentAction action);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportstu/MsrStudentMapper.java

@@ -22,4 +22,6 @@ public interface MsrStudentMapper extends TkMapper<MsrStudent> {
     List<Map<String, Object>> listStuScoreAndRankByExamidAndSubjectid(@Param("examid") int examid, @Param("subjectid") String subjectid);
     //学生报告-学生学科试题分析
     List<Map<String, Object>> listStuSubjectQuestions(@Param("params") ExamReportParams params);
+    //综合报告-总概览-整体分数分布分析
+    List<Map<String, Object>> listScoreForZgl(@Param("examid") Integer examid,@Param("subjectid") String subjectid);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectClassMapper.java

@@ -1,7 +1,12 @@
 package com.xhkjedu.smarking.mapper.report.reportsubject;
 
 import com.xhkjedu.base.TkMapper;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectClass;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 阅卷报告-科目班级分数分布区间分析表 Mapper 接口
@@ -9,4 +14,5 @@ import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectClass;
  * @Date 2024-12-09
  */
 public interface MsrSubjectClassMapper extends TkMapper<MsrSubjectClass> {
+    List<Map> listSubjectClass(@Param("subject") MsrSubject subject);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectMapper.java

@@ -4,6 +4,7 @@ import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -15,4 +16,7 @@ public interface MsrSubjectMapper extends TkMapper<MsrSubject> {
 
     //综合报告-试题汇总表-全部班级-科目情况
     Map<String, Object> getSubjectBaseInfo(@Param("examid")Integer examid, @Param("subjectid")String subjectid);
+
+    //科目分析
+    List<Map> listSubjectForZgl(@Param("examid") Integer examid);
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportsubject/MsrSubject.java

@@ -39,8 +39,10 @@ public class MsrSubject extends BaseBean {
     private Double scorerate;
     //总人数
     private Integer totalnum;
-    //实考人数
+    //参考人数
     private Integer stunum;
+    //参考人数占比
+    private Double numrate;
     //缺考人数
     private Integer missnum;
     //标准差

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGenerateActionService.java

@@ -0,0 +1,149 @@
+package com.xhkjedu.smarking.service.report.generate;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassActionMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentActionMapper;
+import com.xhkjedu.smarking.model.exam.MsClassStudent;
+import com.xhkjedu.smarking.model.paper.MsPaper;
+import com.xhkjedu.smarking.model.report.reportclass.MsrClassAction;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
+import com.xhkjedu.utils.N_Utils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ *@Description 优秀违纪报告生成服务
+ *@Author ywx
+ *Date 2025/1/3 11:39
+ **/
+@Service
+public class ReportGenerateActionService {
+    @Resource
+    private MsrClassActionMapper msrClassActionMapper;
+    @Resource
+    private MsrStudentActionMapper msrStudentActionMapper;
+
+    //违纪优秀分析
+    public void saveAction(Integer examid, List<MsPaper> subjects, List<MsClassStudent> students) {
+        String msids = subjects.stream().map(p -> p.getMsid().toString()).collect(Collectors.joining(","));
+        String subjectids = subjects.stream().map(MsPaper::getSubjectid).collect(Collectors.joining("','"));
+        Map<Integer, String> subjectIdMap = new HashMap<>();
+        Map<String, String> subjectNameMap = new HashMap<>();
+        for (MsPaper subject : subjects) {
+            String subjectid = subject.getSubjectid();
+            String subjectname = subject.getSubjectname();
+            subjectIdMap.put(subject.getMsid(), subjectid);
+            subjectNameMap.put(subjectid, subjectname);
+        }
+        Map<String, List<MsClassStudent>> collect = students.stream().collect(Collectors.groupingBy(s -> s.getSubjectid() + "_" + s.getStudentid()));
+        Map<String, List<Integer>> sscMap = new HashMap<>();//学生科目班级map
+        for (Map.Entry<String, List<MsClassStudent>> entry : collect.entrySet()) {
+            sscMap.put(entry.getKey(), entry.getValue().stream().map(MsClassStudent::getClassid).distinct().collect(Collectors.toList()));
+        }
+
+        List<MsrClassAction> classActions = new ArrayList<>();
+        List<MsrStudentAction> studentActions = new ArrayList<>();
+        //违纪行为
+        List<Map> bads = msrClassActionMapper.listBadActionByExamId(msids);
+        for (Map bad : bads) {
+            String subjectid = subjectIdMap.get((Integer) bad.get("msid"));
+            bad.put("subjectid", subjectid);
+        }
+        int actiontype = 1;
+        setActions(examid, classActions, studentActions, bads, actiontype, subjectNameMap, sscMap);
+        //优秀试卷
+        List<Map> goods = msrClassActionMapper.listGoodActionByExamId(examid, subjectids);
+        actiontype = 2;
+        setActions(examid, classActions, studentActions, goods, actiontype, subjectNameMap, sscMap);
+
+        //违规试卷
+        List<Map> badques = msrClassActionMapper.listBadQuesActionByExamId(examid, subjectids);
+        actiontype = 3;
+        setActions(examid, classActions, studentActions, badques, actiontype, subjectNameMap, sscMap);
+
+        if (N_Utils.isListNotEmpty(classActions)) msrClassActionMapper.insertList(classActions);
+        if (N_Utils.isListNotEmpty(studentActions)) msrStudentActionMapper.insertList(studentActions);
+    }
+
+    //处理行为数据
+    private void setActions(Integer examid, List<MsrClassAction> classActions, List<MsrStudentAction> studentActions
+            , List<Map> actionList, Integer actiontype, Map<String, String> subjectNameMap
+            , Map<String, List<Integer>> sscMap) {
+        if (N_Utils.isListNotEmpty(actionList)) {
+            List<Map> actions = new ArrayList<>();
+            for (Map map : actionList) {
+                String key = map.get("subjectid") + "_" + map.get("studentid");
+                List<Integer> classids = sscMap.get(key);
+                for (Integer classid : classids) {
+                    Map ca = new HashMap(map);
+                    ca.put("classid", classid);
+                    actions.add(ca);
+                }
+            }
+            //班级行为分析
+            Map<Integer, List<Map>> ccollect = actions.stream().collect(Collectors.groupingBy(s -> (Integer) s.get("classid")
+                    , LinkedHashMap::new, Collectors.toList()));
+            for (Map.Entry<Integer, List<Map>> entry : ccollect.entrySet()) {
+                List<Map> subjects = new ArrayList<>();
+                Map<String, List<Map>> scollect = entry.getValue().stream().collect(Collectors.groupingBy(s -> s.get("subjectid").toString()
+                        , LinkedHashMap::new, Collectors.toList()));
+                for (Map.Entry<String, List<Map>> sentry : scollect.entrySet()) {
+                    String subjectid = sentry.getKey();
+                    int znum = (int) actions.stream().filter(s -> s.get("subjectid").equals(subjectid)).count();//总人数
+                    List<Map> list = sentry.getValue();
+                    Map subject = new HashMap();
+                    subject.put("subjectid", subjectid);
+                    subject.put("subjectname", subjectNameMap.get(subjectid));
+                    int num = list.size();
+                    subject.put("num", num);
+                    subject.put("nrate", N_Utils.getIntegerDivideAndMulitiply(num, znum));
+                    List<Map> students = new ArrayList<>();
+                    for (Map s : list) {
+                        Map stu = new HashMap();
+                        Integer studentid = (Integer) s.get("studentid");
+                        stu.put("studentid", studentid);
+                        stu.put("num", s.get("num"));
+                        stu.put("studentname", s.get("studentname"));
+                        students.add(stu);
+                    }
+                    subject.put("students", students);
+                    subjects.add(subject);
+                }
+                MsrClassAction ca = new MsrClassAction();
+                ca.setClassid(entry.getKey());
+                ca.setExamid(examid);
+                ca.setActiontype(actiontype);
+                String subjectjson = JSON.toJSONString(subjects);
+                ca.setSubjectjson(subjectjson);
+                classActions.add(ca);
+            }
+
+            //学生行为分析
+            Map<Integer, List<Map>> collect = actions.stream().collect(Collectors.groupingBy(s -> (Integer) s.get("studentid")
+                    , LinkedHashMap::new, Collectors.toList()));
+            for (Map.Entry<Integer, List<Map>> entry : collect.entrySet()) {
+                List<Map> list = entry.getValue();
+                Map sq = list.get(0);
+                MsrStudentAction sa = new MsrStudentAction();
+                sa.setClassid((Integer) sq.get("classid"));
+                sa.setStudentid(entry.getKey());
+                sa.setExamid(examid);
+                sa.setActiontype(actiontype);
+                for (Map s : list) {
+                    s.remove("classid");
+                    s.remove("studentid");
+                    s.remove("studentname");
+                    s.remove("msid");
+                    s.put("subjectname", subjectNameMap.get(s.get("subjectid").toString()));
+                }
+                String subjectjson = JSON.toJSONString(list);
+                sa.setSubjectjson(subjectjson);
+                studentActions.add(sa);
+            }
+        }
+    }
+
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGenerateClassService.java

@@ -0,0 +1,993 @@
+package com.xhkjedu.smarking.service.report.generate;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.report.reportclass.*;
+import com.xhkjedu.smarking.model.report.reportclass.*;
+import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
+import com.xhkjedu.smarking.service.report.reportother.MsrReportparamService;
+import com.xhkjedu.smarking.utils.MarkingUtil;
+import com.xhkjedu.smarking.vo.report.reportclass.ClassTopVo;
+import com.xhkjedu.smarking.vo.report.reportclass.RankRateGroupVo;
+import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
+import com.xhkjedu.utils.N_Utils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ *@Description : 班级生成报告服务
+ *@Author ywx
+ *Date 2025/1/3 11:07
+ **/
+@Service
+public class ReportGenerateClassService {
+    @Resource
+    private MsrReportparamService msrReportparamService;
+    @Resource
+    private MsrClassSubjectMapper msrClassSubjectMapper;
+    @Resource
+    private MsrClassTopMapper msrClassTopMapper;
+    @Resource
+    private MsrClassSubjectGradeMapper msrClassSubjectGradeMapper;
+    @Resource
+    private MsrClassRankgroupMapper msrClassRankgroupMapper;
+    @Resource
+    private MsrClassRankrateMapper msrClassRankrateMapper;
+    @Resource
+    private MsrClassSectionMapper msrClassSectionMapper;
+    @Resource
+    private MsrClassNearlineMapper msrClassNearlineMapper;
+    @Resource
+    private MsrClassGoodbadMapper msrClassGoodbadMapper;
+
+    //班级学科前60分析
+    public void saveClassTop(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrClassTop> msrClassTops = new ArrayList<>();//班级学科前60分析
+        Map<String, ClassTopVo> lsMap = new HashMap<>();//处于年级60%得分map
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, null);
+            String subjectid = entry.getKey().split("_")[1];
+            List<Double> scores = entry.getValue().stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+            Double lsscore = MarkingUtil.cynjdf(scores, 0.6);
+            List<MsrStudent> lsstudents = entry.getValue().stream().filter(s -> s.getStuscore().compareTo(lsscore) >= 0).collect(Collectors.toList());
+            ClassTopVo classTopVo = new ClassTopVo();
+            classTopVo.setSubjectid(subjectid);
+            classTopVo.setLsscore(lsscore);
+            classTopVo.setXtnum(lsstudents.size());
+            double average = lsstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
+            classTopVo.setXtavgscore(N_Utils.formatDouble(average, 2));
+            String xtstuids = lsstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+            classTopVo.setXtstuids(xtstuids);
+            lsMap.put(subjectid, classTopVo);
+        }
+        setClassTop(examid, collect, lsMap, msrClassTops);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassTop(examid, scCollect, lsMap, msrClassTops);
+        msrClassTopMapper.insertList(msrClassTops);
+    }
+
+    //班级学科前60计算
+    private void setClassTop(Integer examid, Map<String, List<MsrStudent>> scCollect, Map<String, ClassTopVo> lsMap
+            , List<MsrClassTop> msrClassTops) {
+        Integer totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<MsrStudent> studentList = entry.getValue();
+            totalnum = studentList.size();//区间总人数
+
+            MsrClassTop msrClassTop = new MsrClassTop();
+            msrClassTop.setExamid(examid);
+            msrClassTop.setClassid(classid);
+            msrClassTop.setSubjectid(subjectid);
+            msrClassTop.setStunum(totalnum);
+            ClassTopVo classTopVo = lsMap.get(subjectid);//处于年级60%得分
+            Double lsscore = classTopVo.getLsscore();
+            List<MsrStudent> lsstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(lsscore) >= 0).collect(Collectors.toList());
+            msrClassTop.setBtnum(lsstudents.size());
+            msrClassTop.setBtrate(N_Utils.getIntegerDivideAndMulitiply(msrClassTop.getBtnum(), totalnum));
+            double average = lsstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
+            msrClassTop.setBtavgscore(N_Utils.formatDouble(average, 2));
+            String btstuids = lsstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+            msrClassTop.setBtstuids(btstuids);
+            msrClassTop.setXtnum(classTopVo.getXtnum());
+            msrClassTop.setXtavgscore(classTopVo.getXtavgscore());
+            msrClassTop.setXtstuids(classTopVo.getXtstuids());
+            msrClassTops.add(msrClassTop);
+        }
+    }
+
+    //班级学科四率等级分析
+    public void saveClassSubjectGrade(Integer examid, String reportcode, List<MsrStudent> msrStudents) {
+        Map<String, List<SzJsonVo>> qjMap = formatSzJson(msrReportparamService.getMsrReportParams(examid, "scorerate", reportcode));
+        List<MsrClassSubjectGrade> msrClassSubjectGrades = new ArrayList<>();//班级学科分析
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+        }
+        setClassSubjectGrade(examid, reportcode, collect, qjMap, msrClassSubjectGrades, rsMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSubjectGrade(examid, reportcode, scCollect, qjMap, msrClassSubjectGrades, rsMap);
+        msrClassSubjectGradeMapper.insertList(msrClassSubjectGrades);
+    }
+
+    //格式化报告参数
+    private Map<String, List<SzJsonVo>> formatSzJson(List<MsrReportparam> list) {
+        Map<String, List<SzJsonVo>> qjMap = new HashMap<>();
+        for (MsrReportparam param : list) {
+            qjMap.put(param.getSubjectid(), JSON.parseArray(param.getSzjson(), SzJsonVo.class));
+        }
+        return qjMap;
+    }
+
+    //班级学科四率等级计算
+    private void setClassSubjectGrade(Integer examid, String reportcode, Map<String, List<MsrStudent>> scCollect
+            , Map<String, List<SzJsonVo>> qjMap, List<MsrClassSubjectGrade> msrClassSubjectGrades
+            , Map<String, Integer> rsMap) {
+        int totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<SzJsonVo> list = qjMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            totalnum = rsMap.get(subjectid);//科目总人数
+            Double fullscore1 = studentList.get(0).getFullscore();
+            for (SzJsonVo rg : list) {
+                String qjname = rg.getDjkey();
+                double min = MarkingUtil.mul(rg.getMinvalue(), fullscore1);
+                double max = MarkingUtil.mul(rg.getMaxvalue(), fullscore1);
+                List<MsrStudent> qjstudents;
+                if (fullscore1.compareTo(max) == 0) {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0).collect(Collectors.toList());
+                } else {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0 && s.getStuscore().compareTo(max) < 0).collect(Collectors.toList());
+                }
+                int qjnum = qjstudents.size();
+                MsrClassSubjectGrade classSubjectGrade = new MsrClassSubjectGrade();
+                classSubjectGrade.setExamid(examid);
+                classSubjectGrade.setSubjectid(subjectid);
+                classSubjectGrade.setClassid(classid);
+                classSubjectGrade.setReportcode(reportcode);
+                classSubjectGrade.setRangename(qjname);
+                classSubjectGrade.setRangenum(qjnum);
+                classSubjectGrade.setRangerate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
+                double qjavg = qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
+                classSubjectGrade.setDjscore(N_Utils.formatDouble(qjavg, 2));
+                classSubjectGrade.setDjrate(N_Utils.getDoubleDivideAndMulitiply(qjavg, fullscore1));
+                String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+                classSubjectGrade.setStuids(stuids);
+                msrClassSubjectGrades.add(classSubjectGrade);
+            }
+        }
+        Map<String, List<MsrClassSubjectGrade>> collect = msrClassSubjectGrades.stream().collect(Collectors.groupingBy(g -> g.getSubjectid() + "_" + g.getRangename()));
+        for (Map.Entry<String, List<MsrClassSubjectGrade>> entry : collect.entrySet()) {
+            List<MsrClassSubjectGrade> nearlineList = entry.getValue();
+            List<Integer> nums = new ArrayList<>();
+            for (MsrClassSubjectGrade classSubjectGrade : nearlineList) {
+                nums.add(classSubjectGrade.getRangenum());
+            }
+            Map<Integer, Integer> rspm = MarkingUtil.rspm(nums);//人数排名
+            for (MsrClassSubjectGrade classSubjectGrade : nearlineList) {
+                classSubjectGrade.setRangenumrank(rspm.get(classSubjectGrade.getRangenum()));
+            }
+        }
+    }
+
+    //班级学科分析
+    public void saveClassSubject(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrClassSubject> msrClassSubjects = new ArrayList<>();//班级学科分析
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        List<MsrReportparam> scorerate = msrReportparamService.getMsrReportParams(examid, "scorerate", "zh");
+        Map<String, SzJsonVo> tsMap = new HashMap<>();//得分率头部学生比例map
+        int subjectnum = 0;
+        for (MsrReportparam reportparam : scorerate) {
+            SzJsonVo sz = new SzJsonVo();
+            String szjson = reportparam.getSzjson();
+            Integer rptype = reportparam.getRptype();
+            if (rptype.equals(2)) {
+                Map<String, Object> map = JSON.parseObject(szjson, Map.class);
+                sz.setAlltop(N_Utils.obj2Int(map.get("alltop")));
+                sz.setAllbottom(N_Utils.obj2Int(map.get("allbottom")));
+            }
+            String subjectid = reportparam.getSubjectid();
+            tsMap.put(subjectid, sz);
+            if (!"zf".equals(subjectid)) {
+                subjectnum++;
+            }
+        }
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        Map<String, List<Integer>> qkMap = new LinkedHashMap<>();//全科及格率学生map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+            String key = entry.getKey();
+            String subjectid = key.split("_")[1];
+            SzJsonVo sz = tsMap.get(subjectid);
+            if (N_Utils.isTrueInteger(sz.getAlltop())) {
+                List<MsrStudent> studentList = entry.getValue();
+                List<Double> scores = studentList.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+                int totalnum = scores.size();
+                int index = (int) Math.ceil(MarkingUtil.div(MarkingUtil.mul(sz.getAlltop(), totalnum), 100));
+                if (index > totalnum) index = totalnum;
+                int goodvalue = studentList.subList(totalnum - index, totalnum).stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMax();
+                int index2 = (int) Math.ceil(MarkingUtil.div(MarkingUtil.mul(sz.getAllbottom(), totalnum), 100));
+                if (index2 > totalnum) index2 = totalnum;
+                int badvalue = studentList.subList(0, index2).stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMin();
+                sz.setGoodvalue(goodvalue);
+                sz.setBadvalue(badvalue);
+            }
+            //全科及格率
+            if (subjectid.equals("zf")) {
+                List<MsrClassSubjectGrade> grades = msrClassSubjectGradeMapper.listSubjectGradeForQk(examid, "zh");
+                if (N_Utils.isListNotEmpty(grades)) {
+                    Map<String, List<MsrClassSubjectGrade>> rcollect = grades.stream().collect(Collectors.groupingBy(MsrClassSubjectGrade::getRangename, LinkedHashMap::new, Collectors.toList()));
+                    for (Map.Entry<String, List<MsrClassSubjectGrade>> rentry : rcollect.entrySet()) {
+                        String rkey = rentry.getKey();
+                        List<MsrClassSubjectGrade> gradeList = rentry.getValue();
+                        String stuids = gradeList.get(0).getStuids();
+                        List<Integer> ids = new ArrayList<>();
+                        for (String id : stuids.split(",")) {
+                            ids.add(N_Utils.obj2Int(id));
+                        }
+                        if (subjectnum == 1) {
+                            qkMap.put(rkey, ids);
+                        } else if (N_Utils.isListNotEmpty(ids)) {
+                            for (int i = 1; i < gradeList.size(); i++) {
+                                MsrClassSubjectGrade grade = gradeList.get(i);
+                                String stuids2 = grade.getStuids();
+                                List<Integer> ids2 = new ArrayList<>();
+                                for (String id2 : stuids2.split(",")) {
+                                    ids2.add(N_Utils.obj2Int(id2));
+                                }
+                                //交集
+                                if (N_Utils.isListEmpty(ids2)) {
+                                    ids = new ArrayList<>();
+                                    break;
+                                }
+                                ids = ids.stream().filter(ids2::contains).collect(Collectors.toList());
+                                if (N_Utils.isListEmpty(ids)) {
+                                    ids = new ArrayList<>();
+                                    break;
+                                }
+
+                            }
+                        }
+                        qkMap.put(rkey, ids);
+                    }
+                }
+            }
+        }
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "allrate", "all");
+        SzJsonVo vo = JSON.parseObject(params.get(0).getSzjson(), SzJsonVo.class);
+        String calformula = vo.getCalformula();
+        Map<String, MsrClassSubject> csMap = new HashMap<>();//班级学科map
+        setClassSubject(examid, collect, msrClassSubjects, csMap, calformula, tsMap, qkMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSubject(examid, scCollect, msrClassSubjects, csMap, calformula, tsMap, qkMap);
+
+        Map<String, List<MsrClassSubject>> scollect = msrClassSubjects.stream().collect(Collectors.groupingBy(MsrClassSubject::getSubjectid));
+        for (Map.Entry<String, List<MsrClassSubject>> entry : scollect.entrySet()) {
+            List<MsrClassSubject> nearlineList = entry.getValue();
+            if (entry.getKey().equals("zf")) {
+                Map<String, List<Integer>> qknum = new LinkedHashMap<>();
+                for (MsrClassSubject cs : nearlineList) {
+                    List<MsrClassSubjectGrade> grades = cs.getGrades();
+                    for (MsrClassSubjectGrade grade : grades) {
+                        String rangename = grade.getRangename();
+                        Integer rangenum = grade.getRangenum();
+                        if (qknum.containsKey(rangename)) {
+                            qknum.get(rangename).add(rangenum);
+                        } else {
+                            qknum.put(rangename, new ArrayList<>(Collections.singletonList(rangenum)));
+                        }
+                    }
+                }
+                Map<String, Map<Integer, Integer>> qkpm = new LinkedHashMap<>();
+                for (Map.Entry<String, List<Integer>> entry2 : qknum.entrySet()) {
+                    Map<Integer, Integer> rspm = MarkingUtil.rspm(entry2.getValue());
+                    qkpm.put(entry2.getKey(), rspm);
+                }
+
+                for (MsrClassSubject cs : nearlineList) {
+                    List<MsrClassSubjectGrade> grades = cs.getGrades();
+                    for (MsrClassSubjectGrade grade : grades) {
+                        String rangename = grade.getRangename();
+                        Integer rangenum = grade.getRangenum();
+                        Integer rank = qkpm.get(rangename).get(rangenum);
+                        grade.setRangenumrank(rank);
+                    }
+                    cs.setQkjgl(JSON.toJSONString(grades));
+                }
+            }
+            List<Double> classavgscore = new ArrayList<>();//班级平均分列表
+            List<Double> bzf = new ArrayList<>();//标准分列表
+            List<Double> cjl = new ArrayList<>();//超均率列表
+            List<Double> bjl = new ArrayList<>();//比均率列表
+            List<Double> zws = new ArrayList<>();//中位数列表
+            List<Double> ljc = new ArrayList<>();//离均差列表
+            List<Double> zs = new ArrayList<>();//众数列表
+            for (MsrClassSubject cs : nearlineList) {
+                classavgscore.add(cs.getClassavgscore());
+                bzf.add(cs.getBzf());
+                cjl.add(cs.getCjl());
+                bjl.add(cs.getBjl());
+                zws.add(cs.getZws());
+                ljc.add(cs.getLjc());
+                zs.add(cs.getZsmax());
+            }
+            Map<Double, Integer> pjfpm = MarkingUtil.fspm(classavgscore);//班级平均分排名
+            Map<Double, Integer> bzfpm = MarkingUtil.fspm(bzf);//标准分排名
+            Map<Double, Integer> cjlpm = MarkingUtil.fspm(cjl);//超均率排名
+            Map<Double, Integer> bjlpm = MarkingUtil.fspm(bjl);//比均率排名
+            Map<Double, Integer> zwspm = MarkingUtil.fspm(zws);//中位数排名
+            Map<Double, Integer> ljcpm = MarkingUtil.fspm(ljc);//离均差排名
+            Map<Double, Integer> zspm = MarkingUtil.fspm(zs);//众数排名
+            for (MsrClassSubject cs : nearlineList) {
+                cs.setClassavgrank(pjfpm.get(cs.getClassavgscore()));
+                cs.setBzfrank(bzfpm.get(cs.getBzf()));
+                cs.setCjlrank(cjlpm.get(cs.getCjl()));
+                cs.setBjlrank(bjlpm.get(cs.getBjl()));
+                cs.setZwsrank(zwspm.get(cs.getZws()));
+                cs.setLjcrank(ljcpm.get(cs.getLjc()));
+                cs.setZsrank(zspm.get(cs.getZsmax()));
+            }
+        }
+        msrClassSubjectMapper.insertList(msrClassSubjects);
+    }
+
+    //班级学科计算
+    private void setClassSubject(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassSubject> msrClassSubjects, Map<String, MsrClassSubject> csMap, String calformula
+            , Map<String, SzJsonVo> tsMap, Map<String, List<Integer>> qkMap) {
+        String subjectid;
+        MsrClassSubject zf = csMap.get("zf");
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            SzJsonVo ts = tsMap.get(subjectid);
+            MsrClassSubject gs = csMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            studentList.sort(Comparator.comparing(MsrStudent::getStuscore));
+            MsrStudent minStudent = studentList.get(0);
+            int stunum = studentList.size();
+            MsrStudent maxStudent = studentList.get(stunum - 1);
+            Double fullscore = minStudent.getFullscore();
+            MsrClassSubject msrClassSubject = new MsrClassSubject();
+            if ("zf".equals(subjectid)) {
+                List<Integer> studentids = studentList.stream().map(MsrStudent::getStudentid).collect(Collectors.toList());
+                List<MsrClassSubjectGrade> grades = new ArrayList<>();
+                for (Map.Entry<String, List<Integer>> entry2 : qkMap.entrySet()) {
+                    String key2 = entry2.getKey();
+                    List<Integer> ids = entry2.getValue();
+                    //ids与studentList的studentid交集
+                    List<Integer> ids2 = ids.stream().filter(studentids::contains).collect(Collectors.toList());
+                    MsrClassSubjectGrade grade = new MsrClassSubjectGrade();
+                    grade.setRangename(key2);
+                    int rangenum = ids2.size();
+                    grade.setRangenum(rangenum);
+                    grade.setRangerate(N_Utils.getIntegerDivideAndMulitiply(rangenum, stunum));
+                    grade.setStuids(ids2.stream().map(Object::toString).collect(Collectors.joining(",")));
+                    grades.add(grade);
+                }
+                msrClassSubject.setGrades(grades);
+            }
+            msrClassSubject.setExamid(examid);
+            msrClassSubject.setSubjectid(subjectid);
+            msrClassSubject.setClassid(classid);
+            msrClassSubject.setFullscore(fullscore);
+            msrClassSubject.setClassmaxscore(maxStudent.getStuscore());
+            msrClassSubject.setClassmaxrank(maxStudent.getSchoolrank());
+            msrClassSubject.setClassminscore(minStudent.getStuscore());
+            msrClassSubject.setClassminrank(minStudent.getSchoolrank());
+            List<Double> scores = studentList.stream().map(MsrStudent::getStuscore).collect(Collectors.toList());
+            double classavgscore = N_Utils.formatDouble(scores.stream().mapToDouble(Double::doubleValue).summaryStatistics().getAverage(), 2);
+            msrClassSubject.setClassavgscore(classavgscore);
+            double classavgrate = N_Utils.getDoubleDivideAndMulitiply(classavgscore, fullscore);
+            msrClassSubject.setClassavgrate(classavgrate);
+            msrClassSubject.setBzc(MarkingUtil.bzc(scores));
+            if (classid.equals(0)) {
+                msrClassSubject.setSchoolmaxscore(msrClassSubject.getClassmaxscore());
+                msrClassSubject.setSchoolminscore(msrClassSubject.getClassminscore());
+                msrClassSubject.setSchoolavgscore(msrClassSubject.getClassavgscore());
+                msrClassSubject.setSchoolavgrate(msrClassSubject.getClassavgrate());
+                msrClassSubject.setBzf(0.0);
+                msrClassSubject.setCjl(0.0);
+                msrClassSubject.setLjc(0.0);
+                msrClassSubject.setBjl(1.0);
+                msrClassSubject.setDfgxzs(0.0);
+                msrClassSubject.setPjfgxzs(0.0);
+            } else {
+                Double schoolavgscore = gs.getClassavgscore();
+                msrClassSubject.setSchoolmaxscore(gs.getClassmaxscore());
+                msrClassSubject.setSchoolminscore(gs.getClassminscore());
+                msrClassSubject.setSchoolavgscore(schoolavgscore);
+                msrClassSubject.setSchoolavgrate(gs.getClassavgrate());
+                msrClassSubject.setBzf(MarkingUtil.bzf(classavgscore, schoolavgscore, gs.getBzc()));
+                msrClassSubject.setCjl(MarkingUtil.cjl(classavgscore, schoolavgscore));
+                msrClassSubject.setLjc(MarkingUtil.sub(classavgscore, schoolavgscore));
+                msrClassSubject.setBjl(1.0);
+                msrClassSubject.setDfgxzs(MarkingUtil.sub(classavgrate, zf.getClassavgrate()));
+                msrClassSubject.setPjfgxzs(MarkingUtil.sub(classavgscore, zf.getClassavgscore()));
+            }
+            msrClassSubject.setZws(MarkingUtil.zws(scores));
+            List<Double> zs = MarkingUtil.zs(scores);
+            msrClassSubject.setZs(JSON.toJSONString(zs));
+            msrClassSubject.setZsmax(zs.stream().max(Double::compareTo).orElse(0.0));
+            if (N_Utils.isNotEmpty(calformula)) {
+                calformula = calformula.replaceAll("平均分", msrClassSubject.getClassavgscore() + "");
+                calformula = calformula.replaceAll("标准差", msrClassSubject.getBzc() + "");
+                calformula = calformula.replaceAll("最高分", msrClassSubject.getClassmaxscore() + "");
+                calformula = calformula.replaceAll("最低分", msrClassSubject.getClassminscore() + "");
+                calformula = calformula.replaceAll("超均率", msrClassSubject.getCjl() + "");
+                calformula = calformula.replaceAll("标准分", msrClassSubject.getBzf() + "");
+                calformula = calformula.replaceAll("中位数", msrClassSubject.getZws() + "");
+                calformula = calformula.replaceAll("离均差", msrClassSubject.getLjc() + "");
+                calformula = calformula.replaceAll("比均率", msrClassSubject.getBjl() + "");
+                calformula = calformula.replaceAll("众数", msrClassSubject.getZsmax() + "");
+                msrClassSubject.setZhl(MarkingUtil.evaluate(calformula));
+            }
+
+            if (N_Utils.isTrueInteger(ts.getAlltop())) {
+                Double goodAvgScore = N_Utils.formatDouble(studentList.stream().filter(s -> s.getSchoolrank().compareTo(ts.getGoodvalue()) <= 0)
+                                                                      .mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2);
+                Double badAvgScore = N_Utils.formatDouble(studentList.stream().filter(s -> s.getSchoolrank().compareTo(ts.getBadvalue()) >= 0)
+                                                                     .mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2);
+                msrClassSubject.setJhl(MarkingUtil.div(badAvgScore, goodAvgScore));
+            }
+
+            if (classid.equals(0)) {
+                csMap.put(subjectid, msrClassSubject);
+            }
+            msrClassSubjects.add(msrClassSubject);
+        }
+    }
+
+    //学科报告-班级学科名次分组分析
+    public void saveClassRankGroup(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrClassRankgroup> classRankGroups = new ArrayList<>();
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, List<RankGroupVo>> groupsMap = new HashMap<>();
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+            List<MsrStudent> studentList = entry.getValue();
+            int maxRank = studentList.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMax();
+            List<RankGroupVo> groups = MarkingUtil.rankGroup(maxRank, 10);
+            groupsMap.put(studentList.get(0).getSubjectid(), groups);
+        }
+        setClassRankGroup(examid, collect, classRankGroups, groupsMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassRankGroup(examid, scCollect, classRankGroups, groupsMap);
+        msrClassRankgroupMapper.insertList(classRankGroups);
+    }
+
+    //学科报告-班级学科名次分组计算
+    private void setClassRankGroup(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassRankgroup> classRankGroups, Map<String, List<RankGroupVo>> groupsMap) {
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<MsrStudent> studentList = entry.getValue();
+            List<RankGroupVo> groups = groupsMap.get(subjectid);
+            for (RankGroupVo group : groups) {
+                int maxvalue = group.getMaxvalue();
+                int minvalue = group.getMinvalue();
+                List<MsrStudent> qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(minvalue) >= 0 && s.getSchoolrank().compareTo(maxvalue) <= 0).collect(Collectors.toList());
+                MsrClassRankgroup cg = new MsrClassRankgroup();
+                cg.setExamid(examid);
+                cg.setClassid(classid);
+                cg.setSubjectid(subjectid);
+                cg.setRname(group.getGroupname());
+                cg.setRnum(qjstudents.size());
+                String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+                cg.setStuids(stuids);
+                classRankGroups.add(cg);
+            }
+        }
+    }
+
+    //综合报表-名次和比例分析
+    public void saveClassRankRate(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "rankrate", "zh");
+        Map<String, List<SzJsonVo>> qjMap = new HashMap<>();
+        Map<String, Integer> tMap = new HashMap<>();
+        for (MsrReportparam param : params) {
+            String subjectid = param.getSubjectid();
+            qjMap.put(subjectid, JSON.parseArray(param.getSzjson(), SzJsonVo.class));
+            tMap.put(subjectid, param.getRptype());
+        }
+        List<MsrClassRankrate> classRankrates = new ArrayList<>();
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, List<RankRateGroupVo>> sgMap = new HashMap<>();//学科名次分组map
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+            List<RankRateGroupVo> subjectGroupList = new ArrayList<>();//学科名次分组列表
+            String subjectid = entry.getKey().split("_")[1];
+            List<SzJsonVo> list = qjMap.get(subjectid);
+            Integer rptype = tMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            if (rptype.equals(3)) {
+                studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
+            }
+            int totalnum = studentList.size();//总人数
+            Double max = null;
+            Integer minRank = null;
+            int minIndex = 0;
+            Object minRate = null;
+            for (SzJsonVo rg : list) {
+                Object djvalue = rg.getDjvalue();
+                RankRateGroupVo group = new RankRateGroupVo();
+                List<MsrStudent> qjstudents;
+                String ztname;
+                String ctname;
+                if (rptype.equals(1)) {//按名次
+                    ztname = "前" + djvalue + "名";
+                    Integer rank = N_Utils.obj2Int(djvalue);
+                    if (minRank == null) {
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                    } else {
+                        Integer finalMinRank = minRank;
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(finalMinRank) > 0 && s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                        group.setMinrank(minRank);
+                    }
+                    group.setMaxrank(rank);
+                    minRank = rank;
+                    double minScore = N_Utils.handleInfinity(qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getMin());
+                    ctname = ">=" + minScore + "分";
+                } else if (rptype.equals(2)) {//按分数
+                    ztname = ">=" + djvalue + "分";
+                    Double score = MarkingUtil.objToDouble(djvalue);
+                    double minScore = score;
+                    if (max == null) {
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0).collect(Collectors.toList());
+                    } else {
+                        Double finalMax = max;
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0 && s.getStuscore().compareTo(finalMax) < 0).collect(Collectors.toList());
+                        group.setMaxscore(max);
+                    }
+                    group.setMinscore(minScore);
+                    max = score;
+                    minRank = qjstudents.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMin();
+                    ctname = "前" + minRank + "名";
+                } else {//按比例
+                    if (minIndex == 0) {
+                        ztname = "前" + djvalue + "%";
+                    } else {
+                        ztname = "前" + minRate + "%-" + djvalue + "%";
+                    }
+                    int index = (int) Math.ceil(MarkingUtil.div(totalnum * 100, djvalue));
+                    if (index > totalnum) index = totalnum;
+                    qjstudents = studentList.subList(minIndex, index);
+                    minIndex = index;
+                    minRate = djvalue;
+                    DoubleSummaryStatistics statistics = qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
+                    double minScore = N_Utils.handleInfinity(statistics.getMin());
+                    double maxScore = N_Utils.handleInfinity(statistics.getMax());
+                    ctname = "[" + minScore + "-" + maxScore + "]";
+                    group.setMaxscore(maxScore);
+                    group.setMinscore(minScore);
+                }
+                group.setRtype(rptype);
+                group.setZtname(ztname);
+                group.setCtname(ctname);
+                subjectGroupList.add(group);
+            }
+            sgMap.put(subjectid, subjectGroupList);
+        }
+        setClassRankRate(examid, collect, classRankrates, sgMap, rsMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassRankRate(examid, scCollect, classRankrates, sgMap, rsMap);
+        msrClassRankrateMapper.insertList(classRankrates);
+    }
+
+    //综合报表-名次和比例计算
+    private void setClassRankRate(Integer examid, Map<String, List<MsrStudent>> scCollect
+            , List<MsrClassRankrate> classRankrates, Map<String, List<RankRateGroupVo>> sgMap
+            , Map<String, Integer> rsMap) {
+        int totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            totalnum = rsMap.get(subjectid);
+            List<RankRateGroupVo> list = sgMap.get(subjectid);
+            Integer rptype = list.get(0).getRtype();
+            List<MsrStudent> studentList = entry.getValue();
+            if (rptype.equals(3)) {
+                studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
+            }
+            int stunum = studentList.size();//参考人数
+            for (int i = 0; i < list.size(); i++) {
+                RankRateGroupVo rg = list.get(i);
+                List<MsrStudent> qjstudents;
+                if (rptype.equals(1)) {//按名次
+                    if (i == 0) {
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rg.getMaxrank()) >= 0).collect(Collectors.toList());
+                    } else {
+                        qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rg.getMaxrank()) >= 0 && s.getSchoolrank().compareTo(rg.getMinrank()) < 0).collect(Collectors.toList());
+                    }
+                } else {//按分数
+                    if (i == 0) {
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(rg.getMinscore()) >= 0).collect(Collectors.toList());
+                    } else {
+                        qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(rg.getMinscore()) >= 0 && s.getStuscore().compareTo(rg.getMaxscore()) < 0).collect(Collectors.toList());
+                    }
+                }
+                int qjnum = qjstudents.size();
+                MsrClassRankrate rankrate = new MsrClassRankrate();
+                rankrate.setExamid(examid);
+                rankrate.setSubjectid(subjectid);
+                rankrate.setClassid(classid);
+                rankrate.setStunum(stunum);
+                rankrate.setRtype(rptype);
+                rankrate.setZtname(rg.getZtname());
+                rankrate.setCtname(rg.getCtname());
+                rankrate.setRnum(qjnum);
+                rankrate.setRrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
+                String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+                rankrate.setStuids(stuids);
+                classRankrates.add(rankrate);
+            }
+        }
+    }
+
+    //分段统计
+    public void saveClassSection(Integer examid, Integer type, String reportcode, List<MsrStudent> msrStudents) {
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "scoresection", reportcode);
+        Integer rptype = params.get(0).getRptype();
+        Map<String, List<RankGroupVo>> fdMap = new HashMap<>();
+        if (rptype.equals(0)) {//固定步长
+            for (MsrReportparam param : params) {
+                SzJsonVo vo = JSON.parseObject(param.getSzjson(), SzJsonVo.class);
+                List<RankGroupVo> groups = MarkingUtil.fdScore(N_Utils.obj2Int(vo.getMaxvalue()), N_Utils.obj2Int(vo.getMinvalue()), N_Utils.obj2Int(vo.getDjvalue()), type);
+                fdMap.put(param.getSubjectid(), groups);
+            }
+        } else {//不定步长
+            for (MsrReportparam param : params) {
+                List<SzJsonVo> vos = JSON.parseArray(param.getSzjson(), SzJsonVo.class);
+                List<RankGroupVo> groups = MarkingUtil.fdScore(vos, type);
+                fdMap.put(param.getSubjectid(), groups);
+            }
+        }
+
+        List<MsrClassSection> classSections = new ArrayList<>();
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, null);
+        }
+        setClassSection(examid, type, reportcode, collect, fdMap, classSections);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setClassSection(examid, type, reportcode, scCollect, fdMap, classSections);
+        msrClassSectionMapper.insertList(classSections);
+    }
+
+    //分段统计-计算
+    private void setClassSection(Integer examid, Integer type, String reportcode, Map<String, List<MsrStudent>> scCollect
+            , Map<String, List<RankGroupVo>> fdMap, List<MsrClassSection> classSections) {
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<MsrStudent> studentList = entry.getValue();
+            Integer stunum = studentList.size();
+            List<RankGroupVo> groups = fdMap.get(subjectid);
+            for (int i = 0; i < groups.size(); i++) {
+                RankGroupVo group = groups.get(i);
+                int maxvalue = group.getMaxvalue();
+                int minvalue = group.getMinvalue();
+                List<MsrStudent> qjstudents;
+                if (type.equals(1)) {
+                    if (i == 0) {
+                        qjstudents = studentList.stream().filter(s -> MarkingUtil.sub(s.getStuscore(), minvalue) >= 0 && MarkingUtil.sub(s.getStuscore(), maxvalue) <= 0).collect(Collectors.toList());
+                    } else {
+                        qjstudents = studentList.stream().filter(s -> MarkingUtil.sub(s.getStuscore(), minvalue) >= 0 && MarkingUtil.sub(s.getStuscore(), maxvalue) < 0).collect(Collectors.toList());
+                    }
+                } else {
+                    qjstudents = studentList.stream().filter(s -> MarkingUtil.sub(s.getStuscore(), maxvalue) >= 0).collect(Collectors.toList());
+                }
+                MsrClassSection classSection = new MsrClassSection();
+                classSection.setExamid(examid);
+                classSection.setClassid(classid);
+                classSection.setSubjectid(subjectid);
+                classSection.setStunum(stunum);
+                classSection.setType(type);
+                classSection.setReportcode(reportcode);
+                classSection.setFzfw(group.getGroupname());
+                int qjnum = qjstudents.size();
+                classSection.setFzfwnum(qjnum);
+                classSection.setFzfwrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, stunum));
+                String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+                classSection.setStuids(stuids);
+                classSections.add(classSection);
+            }
+        }
+    }
+
+    //分档上线分析
+    public void saveClassNearLine(Integer examid, List<MsrStudent> msrStudents) {
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "gradescore", "all");
+        Map<String, List<SzJsonVo>> qjMap = new HashMap<>();
+        Map<String, Integer> tMap = new HashMap<>();
+        for (MsrReportparam param : params) {
+            String subjectid = param.getSubjectid();
+            qjMap.put(subjectid, JSON.parseArray(param.getSzjson(), SzJsonVo.class));
+            tMap.put(subjectid, param.getRptype());
+        }
+        params = msrReportparamService.getMsrReportParams(examid, "nearline", "all");
+        List<SzJsonVo> vos = JSON.parseArray(params.get(0).getSzjson(), SzJsonVo.class);
+        Map<Integer, List<Integer>> zfSx = null;//学生总分是否上线
+        List<MsrClassNearline> classNearlines = new ArrayList<>();
+        Map<String, List<MsrStudent>> collect0 = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect0.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+            if (entry.getKey().endsWith("zf")) {
+                zfSx = setZfsxMap(entry.getValue(), qjMap, tMap);
+            }
+            setClassNearLine(examid, entry, qjMap, tMap, vos, zfSx, classNearlines, rsMap);
+        }
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            setClassNearLine(examid, entry, qjMap, tMap, vos, zfSx, classNearlines, rsMap);
+        }
+        Map<String, List<MsrClassNearline>> collect = classNearlines.stream().collect(Collectors.groupingBy(l -> l.getSubjectid() + "_" + l.getDworder()));
+        for (Map.Entry<String, List<MsrClassNearline>> entry : collect.entrySet()) {
+            List<MsrClassNearline> nearlineList = entry.getValue();
+            List<Integer> nums = new ArrayList<>();
+            for (MsrClassNearline nearline : nearlineList) {
+                nums.add(nearline.getSxnum());
+            }
+            Map<Integer, Integer> rspm = MarkingUtil.rspm(nums);//人数排名
+            for (MsrClassNearline nearline : nearlineList) {
+                nearline.setSxrank(rspm.get(nearline.getSxnum()));
+            }
+        }
+        msrClassNearlineMapper.insertList(classNearlines);
+    }
+
+    //分档上线计算
+    private void setClassNearLine(Integer examid, Map.Entry<String, List<MsrStudent>> entry, Map<String, List<SzJsonVo>> qjMap
+            , Map<String, Integer> tMap, List<SzJsonVo> vos, Map<Integer, List<Integer>> zfSx
+            , List<MsrClassNearline> classNearlines, Map<String, Integer> rsMap) {
+        String key = entry.getKey();
+        Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+        String subjectid = key.split("_")[1];
+        int totalnum = rsMap.get(subjectid);
+        List<SzJsonVo> list = qjMap.get(subjectid);
+        Integer rptype = tMap.get(subjectid);
+        List<MsrStudent> studentList = entry.getValue();
+        if (rptype.equals(3)) {
+            studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
+        }
+        Double max = null;
+        Integer minRank = null;
+        int minIndex = 0;
+        for (int i = 0; i < list.size(); i++) {
+            SzJsonVo fd = vos.get(i);
+            Double fdMaxScore = fd.getMaxvalue();//档位浮动分数
+            if (fdMaxScore == null) fdMaxScore = MarkingUtil.objToDouble(fd.getDjvalue());
+            Double fdMinScore = fd.getMinvalue();//档位浮动分数
+            if (fdMinScore == null) {
+                fdMinScore = fdMaxScore;
+            }
+            SzJsonVo rg = list.get(i);
+            Object djvalue = rg.getDjvalue();
+            double dwscore;
+            List<MsrStudent> qjstudents;//上线学生列表
+            List<MsrStudent> ljstudents;//累计上线学生列表
+            if (rptype.equals(1)) {//按名次
+                Integer rank = N_Utils.obj2Int(djvalue);
+                ljstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                if (minRank == null) {
+                    qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                } else {
+                    Integer finalMinRank = minRank;
+                    qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(finalMinRank) >= 0 && s.getSchoolrank().compareTo(rank) < 0).collect(Collectors.toList());
+                }
+                minRank = rank;
+                dwscore = N_Utils.handleInfinity(qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getMin());
+            } else if (rptype.equals(2)) {//按分数
+                Double score = MarkingUtil.objToDouble(djvalue);
+                ljstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0).collect(Collectors.toList());
+                if (max == null) {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0).collect(Collectors.toList());
+                } else {
+                    Double finalMax = max;
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0 && s.getStuscore().compareTo(finalMax) < 0).collect(Collectors.toList());
+                }
+                dwscore = MarkingUtil.objToDouble(djvalue);
+                max = score;
+                minRank = qjstudents.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMin();
+            } else {//按比例
+                int index = (int) Math.ceil(MarkingUtil.div(totalnum * 100, djvalue));
+                if (index > totalnum) index = totalnum;
+                qjstudents = studentList.subList(minIndex, index);
+                minIndex = index;
+                DoubleSummaryStatistics statistics = qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
+                dwscore = N_Utils.handleInfinity(statistics.getMin());
+                ljstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(dwscore) >= 0).collect(Collectors.toList());
+            }
+            int qjnum = qjstudents.size();
+            MsrClassNearline nearline = new MsrClassNearline();
+            nearline.setExamid(examid);
+            nearline.setSubjectid(subjectid);
+            nearline.setClassid(classid);
+            Integer dworder = i + 1;
+            String dwname = N_Utils.NumberToChn(dworder) + "档";
+            nearline.setDwname(dwname);
+            nearline.setDworder(dworder);
+            nearline.setDwscore(dwscore);
+            nearline.setSxnum(qjnum);
+            nearline.setSxrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
+            int ljsxnum = ljstudents.size();
+            nearline.setLjsxnum(ljsxnum);
+            nearline.setLjsxrate(N_Utils.getIntegerDivideAndMulitiply(ljsxnum, totalnum));
+            if (!"zf".equals(subjectid)) {
+                List<Integer> zfsxIds = zfSx.get(dworder);//总分上线学生id列表
+                int zfsxnum = zfsxIds.size();
+                List<MsrStudent> ssxIds = qjstudents.stream().filter(s -> zfsxIds.contains(s.getStudentid())).collect(Collectors.toList());
+                Integer ssxnum = ssxIds.size();//双上线人数
+                nearline.setSsxnum(ssxnum);
+                nearline.setStuids2(ssxIds.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+                //总分上线学科未上线人数
+                List<Integer> dksxIds = qjstudents.stream().map(MsrStudent::getStudentid).collect(Collectors.toList());
+                List<Integer> zfsxxkwsxIds = new ArrayList<>(zfsxIds);
+                zfsxxkwsxIds.removeAll(dksxIds);
+                int zfsxxkwsxnum = zfsxxkwsxIds.size();
+                nearline.setZfsxxkwsxnum(zfsxxkwsxnum);
+                nearline.setStuids5(zfsxxkwsxIds.stream().map(Object::toString).collect(Collectors.joining(",")));
+                nearline.setGxrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, zfsxnum));
+                nearline.setMzxrate(N_Utils.getIntegerDivideAndMulitiply(ssxnum, qjnum));
+            }
+            nearline.setSxrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
+            double ljMax = MarkingUtil.add(dwscore, fdMaxScore);
+            double ljMin = MarkingUtil.sub(dwscore, fdMinScore);
+            List<MsrStudent> ljStudents = studentList.stream().filter(s -> s.getStuscore().compareTo(ljMax) <= 0 && s.getStuscore().compareTo(ljMin) >= 0).collect(Collectors.toList());
+            nearline.setLjsnum(ljStudents.size());
+            nearline.setLjsavgscore(N_Utils.formatDouble(ljStudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2));
+            nearline.setStuids3(ljStudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+            nearline.setStuids4(ljstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+            String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+            nearline.setStuids(stuids);
+            classNearlines.add(nearline);
+        }
+    }
+
+    //总分上线分析
+    private Map<Integer, List<Integer>> setZfsxMap(List<MsrStudent> studentList, Map<String, List<SzJsonVo>> qjMap
+            , Map<String, Integer> tMap) {
+        Map<Integer, List<Integer>> zfSx = new HashMap<>();
+        String subjectid = "zf";
+        int totalnum;
+        List<SzJsonVo> list = qjMap.get(subjectid);
+        Integer rptype = tMap.get(subjectid);
+        if (rptype.equals(3)) {
+            studentList = studentList.stream().sorted(Comparator.comparing(MsrStudent::getStuscore).reversed()).collect(Collectors.toList());
+        }
+        totalnum = studentList.size();//总人数
+        Double max = null;
+        Integer minRank = null;
+        int minIndex = 0;
+        for (int i = 0; i < list.size(); i++) {
+            SzJsonVo rg = list.get(i);
+            Object djvalue = rg.getDjvalue();
+            List<MsrStudent> qjstudents;//上线学生列表
+            if (rptype.equals(1)) {//按名次
+                Integer rank = N_Utils.obj2Int(djvalue);
+                if (minRank == null) {
+                    qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(rank) <= 0).collect(Collectors.toList());
+                } else {
+                    Integer finalMinRank = minRank;
+                    qjstudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(finalMinRank) >= 0 && s.getSchoolrank().compareTo(rank) < 0).collect(Collectors.toList());
+                }
+                minRank = rank;
+            } else if (rptype.equals(2)) {//按分数
+                Double score = MarkingUtil.objToDouble(djvalue);
+                if (max == null) {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0).collect(Collectors.toList());
+                } else {
+                    Double finalMax = max;
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(score) >= 0 && s.getStuscore().compareTo(finalMax) < 0).collect(Collectors.toList());
+                }
+                max = score;
+                minRank = qjstudents.stream().mapToInt(MsrStudent::getSchoolrank).summaryStatistics().getMin();
+            } else {//按比例
+                int index = (int) Math.ceil(MarkingUtil.div(totalnum * 100, djvalue));
+                if (index > totalnum) index = totalnum;
+                qjstudents = studentList.subList(minIndex, index);
+                minIndex = index;
+            }
+
+            Integer dworder = i + 1;
+            List<Integer> ids = qjstudents.stream().map(MsrStudent::getStudentid).collect(Collectors.toList());
+            zfSx.put(dworder, ids);
+        }
+        return zfSx;
+    }
+
+    //重点学生-优劣名次统计
+    public void saveClassGoodBad(Integer examid, String all, List<MsrStudent> msrStudents) {
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "keystu", all);
+        SzJsonVo fd = JSON.parseObject(params.get(0).getSzjson(), SzJsonVo.class);
+        List<MsrClassGoodbad> classGoodbads = new ArrayList<>();
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+            setClassGoodBag(examid, entry, fd, classGoodbads, rsMap);
+        }
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            setClassGoodBag(examid, entry, fd, classGoodbads, rsMap);
+        }
+        msrClassGoodbadMapper.insertList(classGoodbads);
+    }
+
+    //重点学生-优劣名次计算
+    private void setClassGoodBag(Integer examid, Map.Entry<String, List<MsrStudent>> entry, SzJsonVo fd
+            , List<MsrClassGoodbad> classGoodbads, Map<String, Integer> rsMap) {
+        String key = entry.getKey();
+        Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+        String subjectid = key.split("_")[1];
+        int totalnum;
+        Integer goodtype = fd.getGoodtype();
+        Integer badtype = fd.getBadtype();
+        List<MsrStudent> studentList = entry.getValue().stream().sorted(Comparator.comparing(MsrStudent::getSchoolrank)).collect(Collectors.toList());
+        Double avgScore = N_Utils.formatDouble(studentList.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2);
+        totalnum = rsMap.get(subjectid);//科目总人数
+        Integer goodvalue = fd.getGoodvalue();
+        Integer badvalue = fd.getBadvalue();
+        List<MsrStudent> yxStudents;//优秀学生列表
+        List<MsrStudent> dtgStudents;//待提高学生列表
+        List<MsrStudent> dbStudents;//学科短板学生列表
+        if (goodtype.equals(1)) {//按名次
+            yxStudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(goodvalue) <= 0).collect(Collectors.toList());
+        } else {//按比例
+            int index = (int) Math.ceil(MarkingUtil.div(totalnum * 100, goodvalue));
+            if (index > totalnum) index = totalnum;
+            yxStudents = studentList.subList(0, index);
+        }
+        if (badtype.equals(1)) {//按名次
+            dtgStudents = studentList.stream().filter(s -> s.getSchoolrank().compareTo(badvalue) <= 0).collect(Collectors.toList());
+        } else {//按比例
+            int index = (int) Math.ceil(MarkingUtil.div(totalnum * 100, badvalue));
+            if (index > totalnum) index = totalnum;
+            //取后index个
+            dtgStudents = studentList.subList(totalnum - index, totalnum);
+        }
+        dbStudents = studentList.stream().filter(s -> s.getStuscore().compareTo(avgScore) <= 0).collect(Collectors.toList());
+        int yxnum = yxStudents.size();
+        MsrClassGoodbad goodbad = new MsrClassGoodbad();
+        goodbad.setExamid(examid);
+        goodbad.setSubjectid(subjectid);
+        goodbad.setClassid(classid);
+        goodbad.setYxnum(yxnum);
+        goodbad.setYxrate(N_Utils.getIntegerDivideAndMulitiply(yxnum, totalnum));
+        goodbad.setYxavgscore(N_Utils.formatDouble(yxStudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2));
+        int dtgnum = dtgStudents.size();
+        goodbad.setDtgnum(dtgnum);
+        goodbad.setDtgrate(N_Utils.getIntegerDivideAndMulitiply(dtgnum, totalnum));
+        goodbad.setDtgavgscore(N_Utils.formatDouble(dtgStudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage(), 2));
+        goodbad.setDbnum(dbStudents.size());
+        goodbad.setStuids(yxStudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+        goodbad.setStuids2(dtgStudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+        goodbad.setStuids3(dbStudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(",")));
+        classGoodbads.add(goodbad);
+    }
+
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGenerateStudentService.java

@@ -0,0 +1,173 @@
+package com.xhkjedu.smarking.service.report.generate;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.report.reportother.MsrReportparamMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.model.exam.MsClassStudent;
+import com.xhkjedu.smarking.model.paper.MsPaper;
+import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
+import com.xhkjedu.smarking.utils.MarkingUtil;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
+import com.xhkjedu.utils.N_Utils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ *@Description : 学生报告生成服务
+ *@Author ywx
+ *Date 2025/1/3 11:29
+ **/
+@Service
+public class ReportGenerateStudentService {
+    @Resource
+    private MsrStudentMapper msrStudentMapper;
+    @Resource
+    private MsrReportparamMapper msrReportparamMapper;
+
+    //保存学生成绩分析
+    public List<MsrStudent> saveStudent(Integer examid, List<MsPaper> subjects, List<MsrStudent> paperStudents
+            , List<MsClassStudent> students, Map<String, MsrSubject> subjectMap) {
+        List<MsrStudent> msrStudents = new ArrayList<>();
+        //等级参数
+        List<MsrReportparam> djParams = msrReportparamMapper.listReportparamByRpbelong(examid, "subjectshow", "all");
+        List<SzJsonVo> djList = new ArrayList<>();
+        if (N_Utils.isListNotEmpty(djParams)) {
+            djList = JSON.parseArray(djParams.get(0).getSzjson(), SzJsonVo.class);
+        }
+
+        double fullscore = subjects.stream().mapToDouble(MsPaper::getPscore).sum();
+        List<MsrStudent> classStudents = new ArrayList<>();//班级学生成绩(总分)
+        List<MsrStudent> classSubjectStudents = new ArrayList<>();//班级科目学生成绩
+        Map<String, Integer> rsMap = new HashMap<>();//各科人数
+        Map<Integer, List<MsrStudent>> schoolCollect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getStudentid));
+        List<Double> zfScores = new ArrayList<>();
+        rsMap.put("zf", schoolCollect.entrySet().size());
+        for (Map.Entry<Integer, List<MsrStudent>> entry : schoolCollect.entrySet()) {
+            List<MsrStudent> list = entry.getValue();
+            Double stuscore = N_Utils.formatDouble(list.stream().mapToDouble(MsrStudent::getStuscore).sum(), 1);
+            zfScores.add(stuscore);
+        }
+        Map<Double, Integer> zfpm = MarkingUtil.fspm(zfScores);//总分分数排名
+        Map<String, Map<Double, Integer>> dkpm = new HashMap<>();//单科分数排名
+        for (MsPaper subject : subjects) {
+            String subjectid = subject.getSubjectid();
+            List<Double> dkScores = paperStudents.stream().filter(s -> s.getSubjectid().equals(subjectid)).map(MsrStudent::getStuscore).collect(Collectors.toList());
+            dkpm.put(subjectid, MarkingUtil.fspm(dkScores));
+            rsMap.put(subjectid, dkScores.size());
+        }
+
+        List<MsrStudent> paperStudents2 = new ArrayList<>();
+        Map<String, List<MsClassStudent>> sClassStudent = students.stream().collect(Collectors.groupingBy(s -> s.getSubjectid() + "_" + s.getStudentid()));
+        for (MsrStudent paperStudent : paperStudents) {
+            String subjectid = paperStudent.getSubjectid();
+            Integer studentid = paperStudent.getStudentid();
+            Double stuscore = paperStudent.getStuscore();
+            Double fullscore1 = paperStudent.getFullscore();
+            String key = subjectid + "_" + studentid;
+            for (MsClassStudent student : sClassStudent.get(key)) {
+                MsrStudent cs = new MsrStudent();
+                cs.setExamid(examid);
+                cs.setClassid(student.getClassid());
+                cs.setStudentid(student.getStudentid());
+                cs.setSubjectid(subjectid);
+                cs.setStuscore(stuscore);
+                cs.setFullscore(fullscore1);
+                paperStudents2.add(cs);
+            }
+        }
+        String subjectid;
+        Map<String, Double> bjdfMap = new HashMap<>();//班级得分
+        Map<Integer, List<MsrStudent>> cCollect = paperStudents2.stream().collect(Collectors.groupingBy(MsrStudent::getClassid));
+        Map<String, Map<Double, Integer>> bkpm = new HashMap<>();//班级科目分数排名
+        for (Map.Entry<Integer, List<MsrStudent>> entry : cCollect.entrySet()) {
+            Integer classid = entry.getKey();
+            subjectid = "zf";
+            List<MsrStudent> studentList = entry.getValue();
+
+            Map<Integer, List<MsrStudent>> sCollect = studentList.stream().collect(Collectors.groupingBy(MsrStudent::getStudentid));
+            List<MsrStudent> rstudents = new ArrayList<>();
+            int totalnum = rsMap.get(subjectid);
+            List<Double> bkScores = new ArrayList<>();
+            for (Map.Entry<Integer, List<MsrStudent>> csEntry : sCollect.entrySet()) {
+                MsrStudent cs = new MsrStudent();
+                cs.setExamid(examid);
+                cs.setClassid(classid);
+                cs.setStudentid(csEntry.getKey());
+                cs.setSubjectid(subjectid);
+                Double stuscore = N_Utils.formatDouble(csEntry.getValue().stream().mapToDouble(MsrStudent::getStuscore).sum(), 1);
+                cs.setStuscore(stuscore);
+                cs.setFullscore(fullscore);
+                cs.setSchoolrank(zfpm.get(stuscore));
+                cs.setHighschool(setHighSchool(studentList, stuscore, totalnum));
+                rstudents.add(cs);
+                bkScores.add(stuscore);
+            }
+            bkpm.put(classid + "_" + subjectid, MarkingUtil.fspm(bkScores));
+            bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
+            classStudents.addAll(rstudents);
+            Map<String, List<MsrStudent>> subCollect = studentList.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
+            for (Map.Entry<String, List<MsrStudent>> ssEntry : subCollect.entrySet()) {
+                bkScores = new ArrayList<>();
+                subjectid = ssEntry.getKey();
+                rstudents = ssEntry.getValue();
+                Map<Double, Integer> dk = dkpm.get(subjectid);
+                totalnum = rsMap.get(subjectid);
+                double csScore = 0;
+                for (MsrStudent rstudent : rstudents) {
+                    Double stuscore = rstudent.getStuscore();
+                    rstudent.setSchoolrank(dk.get(stuscore));
+                    rstudent.setHighschool(setHighSchool(rstudents, stuscore, totalnum));
+                    csScore = MarkingUtil.add(csScore, stuscore);
+                    bkScores.add(stuscore);
+                }
+                bkpm.put(classid + "_" + subjectid, MarkingUtil.fspm(bkScores));
+                bjdfMap.put(classid + "_" + subjectid, csScore);
+                classSubjectStudents.addAll(rstudents);
+            }
+        }
+        //学生成绩分析
+        for (MsrStudent student : classStudents) {
+            setStudent(student, bkpm, bjdfMap, subjectMap, djList);
+        }
+        for (MsrStudent student : classSubjectStudents) {
+            setStudent(student, bkpm, bjdfMap, subjectMap, djList);
+        }
+        msrStudents.addAll(classStudents);
+        msrStudents.addAll(classSubjectStudents);
+        if (N_Utils.isListNotEmpty(msrStudents)) msrStudentMapper.insertList(msrStudents);
+        return msrStudents;
+    }
+
+    //超过年级百分比
+    private Double setHighSchool(List<MsrStudent> studentList, Double stuscore, int totalnum) {
+        long num1 = studentList.stream().filter(s -> s.getStuscore().compareTo(stuscore) == 0).count();
+        long num2 = studentList.stream().filter(s -> s.getStuscore().compareTo(stuscore) > 0).count();
+        int num = totalnum - N_Utils.obj2Int(num1) - N_Utils.obj2Int(num2);
+        return N_Utils.getIntegerDivideAndMulitiply(num, totalnum);
+    }
+
+    //设置学生分析计算参数
+    private void setStudent(MsrStudent student, Map<String, Map<Double, Integer>> bkpm
+            , Map<String, Double> bjdfMap, Map<String, MsrSubject> subjectMap, List<SzJsonVo> djList) {
+        String subjectid;
+        Integer classid = student.getClassid();
+        subjectid = student.getSubjectid();
+        student.setClassrank(bkpm.get(classid + "_" + subjectid).get(student.getStuscore()));
+        MsrSubject msrSubject = subjectMap.get(subjectid);
+        Double pjf = msrSubject.getAvgscore();//年级平均分
+        student.setBzf(MarkingUtil.bzf(bjdfMap.get(classid + "_" + subjectid), pjf, msrSubject.getBzc()));
+        student.setCjl(MarkingUtil.cjl(student.getStuscore(), pjf));
+        Integer totalnum = msrSubject.getTotalnum();
+        double rankrate = MarkingUtil.div(student.getSchoolrank(), totalnum);
+        student.setRankrate(rankrate);//个人成绩排名率=自己所在学科成绩分数的名次/总人数
+        student.setXkqrz(MarkingUtil.sub(msrSubject.getAvgrank(), rankrate));//学科强弱值 = 平均成绩排名率- 个人成绩排名率
+        double dfv = N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), msrSubject.getFullscore());
+        student.setGradevalue(MarkingUtil.dj(dfv, djList));
+    }
+
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/generate/ReportGenerateSubjectService.java

@@ -0,0 +1,223 @@
+package com.xhkjedu.smarking.service.report.generate;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectClassMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectMapper;
+import com.xhkjedu.smarking.mapper.stupaper.MsPaperStudentQuestionMapper;
+import com.xhkjedu.smarking.model.paper.MsPaper;
+import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectClass;
+import com.xhkjedu.smarking.service.report.reportother.MsrReportparamService;
+import com.xhkjedu.smarking.utils.MarkingUtil;
+import com.xhkjedu.smarking.vo.paper.SQScoreVo;
+import com.xhkjedu.smarking.vo.paper.SQuestionVo;
+import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
+import com.xhkjedu.utils.N_Utils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ *@Description 科目生成报告服务
+ *@Author ywx
+ *Date 2025/1/3 11:08
+ **/
+@Service
+public class ReportGenerateSubjectService {
+    @Resource
+    private MsPaperStudentQuestionMapper paperStudentQuestionMapper;
+    @Resource
+    private MsrSubjectMapper msrSubjectMapper;
+    @Resource
+    private MsrSubjectClassMapper msrSubjectClassMapper;
+    @Resource
+    private MsrReportparamService msrReportparamService;
+
+    //保存科目分析
+    public Map<String, MsrSubject> saveSubject(Integer examid, List<MsrStudent> paperStudents
+            , List<MsPaper> subjects, List<Integer> mpids) {
+        double fullscore = subjects.stream().mapToDouble(MsPaper::getPscore).sum();
+        String subjectid;
+        //科目分析
+        Map<String, MsrSubject> subjectMap = new HashMap<>();//科目分析map
+        List<MsrSubject> msrSubjects = new ArrayList<>();
+        MsrSubject msrSubject = new MsrSubject();
+        msrSubject.setExamid(examid);
+        subjectid = "zf";
+        msrSubject.setSubjectid(subjectid);
+        msrSubject.setSubjectname("总分");
+        msrSubject.setFullscore(fullscore);
+        Map<Integer, List<MsrStudent>> collect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getStudentid));
+        List<MsrStudent> studentList = new ArrayList<>();
+        for (Map.Entry<Integer, List<MsrStudent>> entry : collect.entrySet()) {
+            MsrStudent student = new MsrStudent();
+            student.setStudentid(entry.getKey());
+            Double stuscore = N_Utils.formatDouble(entry.getValue().stream().mapToDouble(MsrStudent::getStuscore).sum(), 1);
+            student.setStuscore(stuscore);
+            student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(stuscore, fullscore));
+            int sstate = 0;
+            long count = entry.getValue().stream().filter(s -> s.getSstate().equals(2)).count();
+            if (count > 0) {
+                sstate = 2;
+            }
+            student.setSstate(sstate);
+            studentList.add(student);
+        }
+        List<SQScoreVo> questionScores = paperStudentQuestionMapper.listByMpIds(mpids);//获取参与统计科目单题得分情况
+        List<Double> zfmtfc = new ArrayList<>();
+        Map<String, List<Double>> dkMtfc = new HashMap<>();
+        for (SQScoreVo s : questionScores) {
+            List<Double> mtfc = new ArrayList<>();
+            List<SQuestionVo> questions = s.getQuestions();
+            for (SQuestionVo question : questions) {
+                double fc = MarkingUtil.fc(question.getStuscores());
+                zfmtfc.add(fc);
+                mtfc.add(fc);
+            }
+            dkMtfc.put(s.getSubjectid(), mtfc);
+        }
+        msrSubject.setMtfc(zfmtfc);
+        setSubject(msrSubject, studentList);
+        msrSubjects.add(msrSubject);
+        subjectMap.put(subjectid, msrSubject);
+        for (MsrStudent student : paperStudents) {
+            student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), student.getFullscore()));
+        }
+        Map<String, List<MsrStudent>> subjectCollect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
+        for (MsPaper subject : subjects) {
+            subjectid = subject.getSubjectid();
+            msrSubject = new MsrSubject();
+            msrSubject.setExamid(examid);
+            msrSubject.setSubjectid(subjectid);
+            msrSubject.setSubjectname(subject.getSubjectname());
+            msrSubject.setFullscore(subject.getPscore());
+            studentList = subjectCollect.get(subjectid);
+            msrSubject.setMtfc(dkMtfc.get(subjectid));
+            setSubject(msrSubject, studentList);
+            msrSubjects.add(msrSubject);
+            subjectMap.put(subjectid, msrSubject);
+        }
+        List<Double> avgScores = msrSubjects.stream().map(MsrSubject::getAvgscore).sorted().collect(Collectors.toList());
+        Map<Double, Integer> fspm = MarkingUtil.fspm(avgScores);//平均分排名
+        for (MsrSubject subject : msrSubjects) {
+            subject.setAvgrank(fspm.get(subject.getAvgscore()));
+            subject.setAvgrankrate(MarkingUtil.div(subject.getAvgrank(), subject.getTotalnum()));
+            String subjectid1 = subject.getSubjectid();
+            int pnum;//试卷中的题目总数
+            if ("zf".equals(subjectid1)) {
+                pnum = subjects.stream().mapToInt(MsPaper::getPnum).sum();
+            } else {
+                pnum = subjects.stream().filter(s -> s.getSubjectid().equals(subjectid1)).findFirst().get().getPnum();
+            }
+            subject.setAxdxs(MarkingUtil.axdxs(pnum, subject.getMtfc(), subject.getZffc()));
+        }
+        msrSubjectMapper.insertList(msrSubjects);
+        return subjectMap;
+    }
+
+    //设置科目分析计算参数
+    private void setSubject(MsrSubject msrSubject, List<MsrStudent> studentList) {
+        List<MsrStudent> studentList2 = studentList.stream().filter(s -> s.getSstate().equals(2)).collect(Collectors.toList());//参与统计学生列表
+        int totalnum = studentList.size();
+        int stunum = studentList2.size();
+        int missnum = totalnum - stunum;
+        msrSubject.setTotalnum(totalnum);
+        msrSubject.setStunum(stunum);
+        msrSubject.setNumrate(N_Utils.getIntegerDivideAndMulitiply(stunum, totalnum));
+        msrSubject.setMissnum(missnum);
+        DoubleSummaryStatistics subjectStatistics = studentList2.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
+        double subjectStatisticsMax = N_Utils.handleInfinity(subjectStatistics.getMax());
+        //最低分均不包括0分
+        double subjectStatisticsMin = N_Utils.handleInfinity(subjectStatistics.getMin());
+        double subjectStatisticsAverage = N_Utils.formatDouble(subjectStatistics.getAverage(), 2);
+        msrSubject.setMaxscore(subjectStatisticsMax);
+        msrSubject.setMinscore(subjectStatisticsMin);
+        msrSubject.setAvgscore(subjectStatisticsAverage);
+        Double avgscore = msrSubject.getAvgscore();
+        Double fullscore = msrSubject.getFullscore();
+        msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(avgscore, fullscore));
+        List<Double> scores = studentList.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+        double bzc = MarkingUtil.bzc(scores);
+        msrSubject.setBzc(bzc);
+        msrSubject.setZffc(MarkingUtil.fc(scores));
+        msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, avgscore));
+        msrSubject.setNd(MarkingUtil.div(avgscore, fullscore));
+        msrSubject.setQfd(MarkingUtil.qfd(scores));
+        List<Double> scoreRates = studentList.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
+        double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
+        msrSubject.setDfllc(dfllc);
+        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, msrSubject.getScorerate()));
+        msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
+        msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
+        msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));
+        msrSubject.setBsscore(MarkingUtil.cynjdf(scores, 0.8));
+    }
+
+    //科目班级分数分布区间分析
+    public void saveSubjectClass(Integer examid, List<MsrStudent> msrStudents) {
+        Map<String, SzJsonVo> qjMap = new HashMap<>();
+        List<MsrReportparam> params = msrReportparamService.getMsrReportParams(examid, "scoresection", "xk");
+        for (MsrReportparam param : params) {
+            qjMap.put(param.getSubjectid(), JSON.parseObject(param.getSzjson(), SzJsonVo.class));
+        }
+        List<MsrSubjectClass> msrSubjectClasses = new ArrayList<>();//科目班级分数分布区间分析
+        Map<String, List<MsrStudent>> collect = MarkingUtil.getSubjectCollect(msrStudents);
+        Map<String, Integer> rsMap = new HashMap<>();//学科人数map
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            MarkingUtil.studentsDistinct(entry, rsMap);
+        }
+        setSubjectClass(examid, collect, qjMap, msrSubjectClasses, rsMap);
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        setSubjectClass(examid, scCollect, qjMap, msrSubjectClasses, rsMap);
+        msrSubjectClassMapper.insertList(msrSubjectClasses);
+    }
+
+    //科目班级分数分布区间计算
+    private void setSubjectClass(Integer examid, Map<String, List<MsrStudent>> scCollect, Map<String, SzJsonVo> qjMap
+            , List<MsrSubjectClass> msrSubjectClasses, Map<String, Integer> rsMap) {
+        Integer totalnum;
+        String subjectid;
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            SzJsonVo vo = qjMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            totalnum = rsMap.get(subjectid);//科目总人数
+            Double fullscore = studentList.get(0).getFullscore();
+            List<RankGroupVo> fdScore = MarkingUtil.fdScore(fullscore, N_Utils.obj2Int(vo.getDjvalue()));
+            for (RankGroupVo rg : fdScore) {
+                int minscore = rg.getMinvalue();
+                int maxscore = rg.getMaxvalue();
+                String qjname = rg.getGroupname();
+                double min = MarkingUtil.objToDouble(minscore);
+                double max = MarkingUtil.objToDouble(maxscore);
+                List<MsrStudent> qjstudents;
+                if (fullscore.compareTo(max) == 0) {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0).collect(Collectors.toList());
+                } else {
+                    qjstudents = studentList.stream().filter(s -> s.getStuscore().compareTo(min) >= 0 && s.getStuscore().compareTo(max) < 0).collect(Collectors.toList());
+                }
+                int qjnum = qjstudents.size();
+                MsrSubjectClass msrSubjectClass = new MsrSubjectClass();
+                msrSubjectClass.setExamid(examid);
+                msrSubjectClass.setSubjectid(subjectid);
+                msrSubjectClass.setClassid(classid);
+                msrSubjectClass.setQjname(qjname);
+                msrSubjectClass.setQjnum(qjnum);
+                msrSubjectClass.setQjrate(N_Utils.getIntegerDivideAndMulitiply(qjnum, totalnum));
+                double qjavg = qjstudents.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics().getAverage();
+                msrSubjectClass.setQjavgrate(N_Utils.getDoubleDivideAndMulitiply(qjavg, fullscore));
+                String stuids = qjstudents.stream().map(s -> s.getStudentid().toString()).collect(Collectors.joining(","));
+                msrSubjectClass.setStuids(stuids);
+                msrSubjectClasses.add(msrSubjectClass);
+            }
+        }
+    }
+
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/report/MsrActionService.java

@@ -0,0 +1,33 @@
+package com.xhkjedu.smarking.service.report.report;
+
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassActionMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentActionMapper;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudentAction;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+/**
+ *@Description 优秀违纪报告查询服务
+ *@Author ywx
+ *Date 2025/1/3 14:33
+ **/
+@Service
+public class MsrActionService {
+    @Resource
+    private MsrClassActionMapper msrClassActionMapper;
+    @Resource
+    private MsrStudentActionMapper msrStudentActionMapper;
+
+    //行为分析-班级
+    public List<Map> listXwBj(MsrStudentAction action) {
+        return msrClassActionMapper.listXwBj(action);
+    }
+
+    //行为分析-学生
+    public List<Map> listXwXs(MsrStudentAction action) {
+        return msrStudentActionMapper.listXwBj(action);
+    }
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/report/MsrClassService.java

@@ -0,0 +1,12 @@
+package com.xhkjedu.smarking.service.report.report;
+
+import org.springframework.stereotype.Service;
+
+/**
+ *@Description 班级报告查询服务
+ *@Author ywx
+ *Date 2025/1/3 14:31
+ **/
+@Service
+public class MsrClassService {
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/report/MsrSubjectService.java

@@ -0,0 +1,45 @@
+package com.xhkjedu.smarking.service.report.report;
+
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassSubjectGradeMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectMapper;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+/**
+ *@Description 科目报告查询服务
+ *@Author ywx
+ *Date 2025/1/3 14:32
+ **/
+@Service
+public class MsrSubjectService {
+    @Resource
+    private MsrSubjectMapper msrSubjectMapper;
+    @Resource
+    private MsrStudentMapper msrStudentMapper;
+    @Resource
+    private MsrClassSubjectGradeMapper msrClassSubjectGradeMapper;
+
+    /**
+     * @Description 总概览
+     * @Date 2025/1/3 15:49
+     * @Author YWX
+     * @Param [subject]
+     * @Return java.util.Map
+     **/
+    public Map<String, Object> listSubjectForZgl(MsrSubject subject) {
+        Integer examid = subject.getExamid();
+        Map<String, Object> map = new LinkedHashMap<>();
+        //总人数、平均分、标准差、难度、差异系数分析
+        map.put("subjects", msrSubjectMapper.listSubjectForZgl(examid));
+        //整体分数分布分析
+        map.put("scores", msrStudentMapper.listScoreForZgl(examid,"zf"));
+        //整体四率分析
+        map.put("scorerates", msrClassSubjectGradeMapper.getZfScoreRate(examid));
+        return map;
+    }
+}

smarking/src/main/java/com/xhkjedu/smarking/service/report/reportother/MsrReportparamService.java

@@ -126,4 +126,13 @@ public class MsrReportparamService {
         msrReportparamMapper.insertList(saveParams);
         return saveParams;
     }
+
+    //获取报告参数
+    public List<MsrReportparam> getMsrReportParams(Integer examid, String rpbelong, String reportcode) {
+        List<MsrReportparam> list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, reportcode);
+        if (N_Utils.isListEmpty(list) && !"all".equals(reportcode)) {
+            list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, "all");
+        }
+        return list;
+    }
 }

smarking/src/main/java/com/xhkjedu/smarking/utils/MarkingUtil.java

@@ -3,6 +3,9 @@ package com.xhkjedu.smarking.utils;
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.xhkjedu.smarking.config.ConfigKey;
+import com.xhkjedu.smarking.mapper.report.reportother.MsrReportparamMapper;
+import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
 import com.xhkjedu.smarking.vo.paper.PaperFileVo;
 import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
 import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
@@ -799,6 +802,38 @@ public class MarkingUtil {
         return N_Utils.formatDouble((k / (k - 1)) * (1 - (sumA / b)), 2);
     }
 
+    //获取科学分组学生
+    public static Map<String, List<MsrStudent>> getSubjectCollect(List<MsrStudent> msrStudents) {
+        Map<String, List<MsrStudent>> map = new LinkedHashMap<>();
+        LinkedHashMap<String, List<MsrStudent>> collect = msrStudents.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid, LinkedHashMap::new, Collectors.toList()));
+        for (Map.Entry<String, List<MsrStudent>> entry : collect.entrySet()) {
+            map.put("0_" + entry.getKey(), entry.getValue());
+        }
+        return map;
+    }
+
+    //学生去重
+    public static void studentsDistinct(Map.Entry<String, List<MsrStudent>> entry, Map<String, Integer> rsMap) {
+        //list根据学生id去重
+        Map<Integer, MsrStudent> map = new HashMap<>();
+        for (MsrStudent student : entry.getValue()) {
+            map.putIfAbsent(student.getStudentid(), student);
+        }
+        List<MsrStudent> list = new ArrayList<>(map.values());
+        entry.setValue(list);
+        if (rsMap != null) rsMap.put(list.get(0).getSubjectid(), list.size());
+    }
+
+    //获取报告参数
+    public static List<MsrReportparam> getMsrReportParams(MsrReportparamMapper msrReportparamMapper
+            ,Integer examid, String rpbelong, String reportcode) {
+        List<MsrReportparam> list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, reportcode);
+        if (N_Utils.isListEmpty(list) && !"all".equals(reportcode)) {
+            list = msrReportparamMapper.listReportparamByRpbelong(examid, rpbelong, "all");
+        }
+        return list;
+    }
+
     public static void main(String[] args) {
        List<RankGroupVo> list = fdScore(1.0,5);
        for (RankGroupVo rgvo : list) {

smarking/src/main/resources/mapper/exam/MsClassMapper.xml

@@ -119,4 +119,8 @@
     <select id="listClassByExamidAndSubjectid" resultType="com.xhkjedu.smarking.model.exam.MsClass">
         select classid,classname,classtype from ms_class where examid=#{examid} and subjectid=#{subjectid} order by mcid
     </select>
+    <!--获取考试关联班级数量-->
+    <select id="getClassNumByExamId" resultType="java.lang.Integer">
+        select count(distinct classid) from ms_class where examid=#{examid}
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportclass/MsrClassActionMapper.xml

@@ -22,4 +22,17 @@
         where psq.examid=#{examid} and psq.subjectid in(#{subjectids}) and hasbad=1
         group by psq.studentid, psq.subjectid
     </select>
+    <!--行为分析-班级-->
+    <select id="listXwBj" resultType="java.util.Map">
+        select c.classname,ca.classid,ca.subjectjson
+        from msr_rclass_action ca left join t_class c on ca.classid = c.classid
+        where ca.examid=#{action.examid} and ca.actiontype=#{action.actiontype}
+        <if test="action.classid!=null and action.classid!=0">
+            and ca.classid=#{action.classid}
+        </if>
+        <foreach collection="action.classids" item="classid" open="and ca.classid in(0," separator="," close=")">
+            ${classid}
+        </foreach>
+        order by c.classtype,c.classorder,c.classid
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportclass/MsrClassSubjectGradeMapper.xml

@@ -7,12 +7,18 @@
         select * from msr_class_subject_grade where examid = #{sg.examid} and subjectid = #{sg.subjectId}
         and reportcode = #{sg.reportCode} and classid = #{sg.classId}
     </select>
-    <!--综合报告-班级堆积-全科及格率分析-->
+    <!--综合报告-班级对比-全科及格率分析-->
     <select id="listSubjectGradeForQk" resultType="com.xhkjedu.smarking.model.report.reportclass.MsrClassSubjectGrade">
         select subjectid,rangename,stuids
         from msr_class_subject_grade
         where examid = #{examid} and classid = 0 and reportcode = #{reportcode}
     </select>
+    <!--综合报告-整体四率分析-->
+    <select id="getZfScoreRate" resultType="java.util.Map">
+        select rangename,rangenum,rangerate
+        from msr_class_subject_grade
+        where examid = #{examid} and reportcode = #{reportcode} and classid = 0 and subjectid = 'zf'
+    </select>
 
 </mapper>
 

smarking/src/main/resources/mapper/report/reportstu/MsrStudentActionMapper.xml

@@ -1,4 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentActionMapper">
+    <!--行为分析-学生-->
+    <select id="listXwBj" resultType="java.util.Map">
+        select c.classname,sa.classid,sa.studentid,sa.subjectjson,u.username,u.loginname
+        from msr_student_action sa left join t_class c on sa.classid = c.classid
+        left join t_user u on sa.studentid=u.userid
+        where sa.examid=#{action.examid} and sa.actiontype=#{action.actiontype}
+        <if test="action.classid!=null and action.classid!=0">
+            and sa.classid=#{action.classid}
+        </if>
+        <foreach collection="action.classids" item="classid" open="and sa.classid in(0," separator="," close=")">
+            ${classid}
+        </foreach>
+        <if test="action.createname!=null and action.createname!=''">
+            and (u.username like '%${action.createname}%' or u.loginname like '%${action.createname}%')
+        </if>
+        order by c.classtype,c.classorder,c.classid
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportstu/MsrStudentMapper.xml

@@ -65,4 +65,11 @@
         where q.examid=#{params.examid} and q.subjectid=#{params.subjectid} and q.studentid=#{params.studentid}
         order by q.mptqid
     </select>
+    <!--综合报告-总概览-整体分数分布分析-->
+    <select id="listScoreForZgl" resultType="java.util.Map">
+        select stuscore,count(*) as num
+        from msr_student
+        where examid=#{examid} and subjectid=#{subjectid}
+        group by stuscore
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectClassMapper.xml

@@ -1,4 +1,9 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectClassMapper">
+    <select id="listSubjectClass" resultType="java.util.Map">
+        select *
+        from msr_subject_class
+        where examid = #{subject.examid}
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectMapper.xml

@@ -7,5 +7,14 @@
         select sid,examid,subjectid,avgscore,nd,qfd,maxscore,minscore,stunum from msr_subject
         where examid=#{examid} and subjectid=#{subjectid}
     </select>
+    <!--综合报告-总概览-->
+    <select id="listSubjectForZgl" resultType="java.util.Map">
+        select sid,subjectid,subjectname
+        ,totalnum,stunum,numrate
+        ,fullscore,avgscore,scorerate
+        ,bzc,nd,cyxs
+        from msr_subject
+        where examid=#{examid}
+    </select>
 
 </mapper>