单科等级分布

sexam/src/main/java/com/xhkjedu/sexam/mapper/report/EReportGenerateMapper.java

 
     //学生优秀行为
     List<Map> listGoodActionByExamId(@Param("examid") Integer examid);
+
+    //获取试卷分数
+    Double getScoreByExamAndSubjectId(@Param("examid") Integer examid, @Param("subjectid") String subjectid);
 }

sexam/src/main/java/com/xhkjedu/sexam/mapper/report/EReportSchoolMapper.java

 package com.xhkjedu.sexam.mapper.report;
 
 import com.xhkjedu.sexam.model.reportstu.ERstudentAction;
-import com.xhkjedu.sexam.vo.report.ERPaperVo;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
  * @date 2022/8/29 10:00
  **/
 public interface EReportSchoolMapper {
-    //考试试卷
-    List<ERPaperVo> listByExamAndSubjectId(@Param("examid") Integer examid, @Param("subjectid") String subjectid);
-
     //删除考试等级报告
     void delByExamAndSubjectId(@Param("examid") Integer examid, @Param("subjectid") String subjectid, @Param("ranktype") Integer ranktype);
 

sexam/src/main/java/com/xhkjedu/sexam/service/report/EReportClassService.java

 import com.xhkjedu.sexam.mapper.reportclass.ERclassRankMapper;
 import com.xhkjedu.sexam.mapper.reportclass.EReportClassMapper;
 import com.xhkjedu.sexam.mapper.reportstu.ERstudentMapper;
-import com.xhkjedu.sexam.mapper.system.UserMapper;
 import com.xhkjedu.sexam.model.paper.EPaperQtype;
 import com.xhkjedu.sexam.model.reportstu.ERstudent;
 import com.xhkjedu.sexam.model.reportstu.ERstudentAction;
-import com.xhkjedu.sexam.vo.report.ERPaperVo;
 import com.xhkjedu.sexam.vo.report.ERankParamVo;
-import com.xhkjedu.sexam.vo.system.UserVo;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
     private EReportSchoolMapper eReportSchoolMapper;
     @Resource
     private EPaperStudentMapper ePaperStudentMapper;
-    @Resource
-    private UserMapper userMapper;
 
     //考试概况-学科成绩
     public List<Map> listXkCj(Integer examid, Integer classid) {
         Integer createid = rank.getCreateid();
         Integer ranktype = rank.getRanktype();
         eReportSchoolMapper.delByExamAndSubjectId(examid, subjectid, ranktype);//删除考试等级报告
-        List<ERPaperVo> papers = eReportSchoolMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷
-        List<ERstudent> students = ePaperStudentMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷学生
-        List<Integer> userids = students.stream().map(ERstudent::getStudentid).distinct().collect(Collectors.toList());
-        List<UserVo> users = userMapper.listNameByUserIds(userids);
-        Map<Integer, String> userMap = users.stream().collect(Collectors.toMap(UserVo::getUserid, UserVo::getUsername));
-        eReportGenerateService.setClassGradeRank(examid, papers, students, rank.getRranks(), createid, userMap);//生成考试等级报告
+        eReportGenerateService.setSubjectRank(examid, subjectid, createid, rank.getRranks(), ranktype);//生成考试等级报告
         return eRclassRankMapper.listByExamId(rank);//考试等级报告列表
     }
 

sexam/src/main/java/com/xhkjedu/sexam/service/report/EReportGenerateService.java

         eRclassRankMapper.insertList(rclassRankList);
     }
 
+    //单科等级分布
+    public void setSubjectRank(Integer examid, String subjectid, Integer createid, List<ERrank> rranks, Integer ranktype) {
+        Double pscore = eReportGenerateMapper.getScoreByExamAndSubjectId(examid, subjectid);//获取试卷分数
+        List<ERstudent> students = ePaperStudentMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷学生
+        List<Integer> userids = students.stream().map(ERstudent::getStudentid).distinct().collect(Collectors.toList());
+        List<UserVo> users = userMapper.listNameByUserIds(userids);
+        Map<Integer, String> userMap = users.stream().collect(Collectors.toMap(UserVo::getUserid, UserVo::getUsername));
+        List<ERstudent> cstudents = new ArrayList<>();//班级学生
+        Map<String, List<ERstudent>> cscollect = students.stream().collect(
+                Collectors.groupingBy(s -> s.getClassid() + "_" + s.getStudentid()));
+        setStuScore(cscollect, cstudents);
+        //总分统计
+        Map<Integer, List<ERstudent>> zfcollect = cstudents.stream().collect(
+                Collectors.groupingBy(s -> s.getClassid()));
+        List<ERstudent> sstudents = new ArrayList<>();//科目学生
+        Map<String, List<ERstudent>> sscollect = students.stream().collect(
+                Collectors.groupingBy(s -> s.getSubjectid() + "_" + s.getStudentid()));
+        setStuScore(sscollect, sstudents);
+        //全部班级统计
+        Map<String, List<ERstudent>> qbbjcollect = sstudents.stream().collect(
+                Collectors.groupingBy(s -> s.getSubjectid()));
+
+        List<ERrank> rrankList = new ArrayList<>();//考试报告等级
+        List<ERclassRank> rclassRankList = new ArrayList<>();//考试报告班级统计
+        ERrank eRrank = rranks.get(0);
+        if (ranktype == 1) {//等级（A[85%~100%],B[70%~85%),C[60%~70%),D[40%~60%),E[0%~40%)）
+            for (ERrank rank : rranks) {
+                Double maxrate = rank.getMaxscore();
+                Double minrate = rank.getMinscore();
+                String rankname = rank.getRankname();
+                if ("zf".equals(subjectid)) {
+                    //总分统计
+                    double zfmaxscore = ExamUtil.mul(maxrate, pscore);
+                    double zfminscore = ExamUtil.mul(minrate, pscore);
+                    ERrank rr = new ERrank();
+                    rr.setRanktype(ranktype);
+                    rr.setRankname(rankname);
+                    rr.setMaxscore(zfmaxscore);
+                    rr.setMinscore(zfminscore);
+                    rr.setSubjectid("zf");
+                    String zfrankrange = "[" + zfminscore + "," + zfmaxscore;
+                    if (rr.getRankname().equals("A")) {
+                        zfrankrange = zfrankrange + "]";
+                    } else {
+                        zfrankrange = zfrankrange + ")";
+                    }
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setDjTj(examid, userMap, rclassRankList, rr, zfrankrange, subjectid, classid, list);
+                    }
+                    IntSummaryStatistics zfstatistics = cstudents.stream().mapToInt(s -> s.getSchoolrank()).summaryStatistics();
+                    rr.setLinescore(zfstatistics.getMax());
+                    rr.setFloatscore(zfstatistics.getMin());
+                    rrankList.add(rr);
+                } else {
+                    //分科统计
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    rrank.setRankname(rankname);
+                    rrank.setSubjectid(subjectid);
+                    double maxscore = ExamUtil.mul(maxrate, pscore);
+                    double minscore = ExamUtil.mul(minrate, pscore);
+                    rrank.setMaxscore(maxscore);
+                    rrank.setMinscore(minscore);
+                    String rankrange = "[" + minscore + "," + maxscore;
+                    if (rankname.equals("A")) {
+                        rankrange = rankrange + "]";
+                    } else {
+                        rankrange = rankrange + ")";
+                    }
+
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    setDjTj(examid, userMap, rclassRankList, rrank, rankrange, subjectid, classid, list);
+                    IntSummaryStatistics statistics = list.stream().mapToInt(s -> s.getSchoolrank()).summaryStatistics();
+                    rrank.setLinescore(statistics.getMax());
+                    rrank.setFloatscore(statistics.getMin());
+                    rrankList.add(rrank);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        setDjTj(examid, userMap, rclassRankList, rrank, rankrange, subjectid, classid, list);
+                    }
+                }
+            }
+        } else if (ranktype == 2) {//分数段（10分/段）
+            Integer linescore = eRrank.getLinescore();
+            if ("zf".equals(subjectid)) {
+                //总分统计
+                Integer gnum = ExamUtil.divUp(pscore, linescore);
+                for (Integer i = 1; i <= gnum; i++) {
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    double maxscore = ExamUtil.mul(i, linescore);
+                    double minscore = ExamUtil.mul(i - 1, linescore);
+                    if (maxscore > pscore) {
+                        maxscore = pscore;
+                    }
+                    rrank.setMaxscore(maxscore);
+                    rrank.setMinscore(minscore);
+                    String rankrange = "[" + minscore + "," + maxscore;
+                    if (i == gnum) {
+                        rankrange = rankrange + "]";
+                    } else {
+                        rankrange = rankrange + ")";
+                    }
+                    rrank.setRankname(rankrange);
+                    rrank.setSubjectid("zf");
+                    rrankList.add(rrank);
+
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setFdTj(examid, userMap, rclassRankList, gnum, i, rrank, rankrange, classid, list);
+                    }
+                }
+            } else {
+                //分科统计
+                Integer cnum = ExamUtil.divUp(pscore, linescore);
+                for (Integer i = 1; i <= cnum; i++) {
+                    ERrank rrank = new ERrank();
+                    rrank.setSubjectid(subjectid);
+                    rrank.setRanktype(ranktype);
+                    rrank.setSubjectid(subjectid);
+                    double maxscore = ExamUtil.mul(i, linescore);
+                    double minscore = ExamUtil.mul(i - 1, linescore);
+                    if (maxscore > pscore) {
+                        maxscore = pscore;
+                    }
+                    rrank.setMaxscore(maxscore);
+                    rrank.setMinscore(minscore);
+                    String rankrange = "[" + minscore + "," + maxscore;
+                    if (i == cnum) {
+                        rankrange = rankrange + "]";
+                    } else {
+                        rankrange = rankrange + ")";
+                    }
+                    rrank.setRankname(rankrange);
+                    rrankList.add(rrank);
+
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    setFdTj(examid, userMap, rclassRankList, cnum, i, rrank, rankrange, classid, list);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        setFdTj(examid, userMap, rclassRankList, cnum, i, rrank, rankrange, classid, list);
+                    }
+                }
+            }
+        } else {
+            Integer lscore = eRrank.getLinescore();
+            if (ranktype == 3) {//临界分（临界分：总分*80%，浮动分：5分）
+                Integer linescore = lscore;
+                Integer floatscore = eRrank.getFloatscore();
+                ERrank rr = new ERrank();
+                rr.setRanktype(ranktype);
+                if ("zf".equals(subjectid)) {
+                    //总分统计
+                    if (N_Utils.isEmptyInteger(linescore)) linescore = (int) (ExamUtil.mul(pscore, 0.8));
+                    double zfmaxscore = ExamUtil.add(linescore, floatscore);
+                    double zfminscore = ExamUtil.sub(linescore, floatscore);
+                    if (zfmaxscore > pscore) zfmaxscore = pscore;
+                    if (zfminscore < 0) zfminscore = 0;
+                    rr.setMaxscore(zfmaxscore);
+                    rr.setMinscore(zfminscore);
+                    rr.setLinescore(linescore);
+                    rr.setFloatscore(floatscore);
+                    String zfrankrange = "[" + zfminscore + "," + zfmaxscore + "]";
+                    rr.setRankname(zfrankrange);
+                    rr.setSubjectid("zf");
+                    rrankList.add(rr);
+
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setLjfTj(examid, userMap, rclassRankList, rr, zfrankrange, classid, subjectid, list);
+                    }
+                } else {
+                    //分科统计
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    rrank.setSubjectid(subjectid);
+                    linescore = lscore;
+                    if (N_Utils.isEmptyInteger(linescore)) linescore = (int) (ExamUtil.mul(pscore, 0.8));
+                    double maxscore = ExamUtil.add(linescore, floatscore);
+                    double minscore = ExamUtil.sub(linescore, floatscore);
+                    if (maxscore > pscore) maxscore = pscore;
+                    if (minscore < 0) minscore = 0;
+                    rrank.setMaxscore(maxscore);
+                    rrank.setMinscore(minscore);
+                    rrank.setLinescore(linescore);
+                    rrank.setFloatscore(floatscore);
+                    String rankrange = "[" + minscore + "," + maxscore + "]";
+                    rrank.setRankname(rankrange);
+                    rrankList.add(rrank);
+
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    setLjfTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        setLjfTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+                    }
+                }
+
+            } else if (ranktype == 4) {//临界名次（临界名次10，浮动名次5）
+                Integer linescore = lscore;
+                Integer floatscore = eRrank.getFloatscore();
+                ERrank rr = new ERrank();
+                rr.setRanktype(ranktype);
+                if ("zf".equals(subjectid)) {
+                    //总分统计
+                    double zfmaxscore = ExamUtil.sub(linescore, floatscore);//最高名次
+                    double zfminscore = ExamUtil.add(linescore, floatscore);//最低名次
+                    if (zfmaxscore < 1) zfmaxscore = 1;//最高名次为1
+                    int zfstunum = (int) students.stream().map(s -> s.getStudentid()).distinct().count();//学生数量
+                    if (zfminscore > zfstunum) zfminscore = zfstunum;//最低名次=学生数量
+                    rr.setMaxscore(zfmaxscore);
+                    rr.setMinscore(zfminscore);
+                    rr.setLinescore(linescore);
+                    rr.setFloatscore(floatscore);
+                    String zfrankrange = "[" + zfminscore + "," + zfmaxscore + "]";
+                    rr.setRankname(zfrankrange);
+                    rr.setSubjectid("zf");
+                    rrankList.add(rr);
+
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setLjmcTj(examid, userMap, rclassRankList, rr, zfrankrange, classid, subjectid, list);
+                    }
+                } else {
+                    //分科统计
+                    double maxscore = ExamUtil.sub(linescore, floatscore);//最高名次
+                    double minscore = ExamUtil.add(linescore, floatscore);//最低名次
+                    if (maxscore < 1) maxscore = 1;//最高名次为1
+                    Integer stunum = students.size();//学生数量
+                    if (minscore > stunum) minscore = stunum;//最低名次=学生数量
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    rrank.setSubjectid(subjectid);
+                    rrank.setMaxscore(maxscore);
+                    rrank.setMinscore(minscore);
+                    rrank.setLinescore(linescore);
+                    rrank.setFloatscore(floatscore);
+                    String rankrange = "[" + minscore + "," + maxscore + "]";
+                    rrank.setRankname(rankrange);
+                    rrankList.add(rrank);
+
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    setLjmcTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        setLjmcTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+                    }
+                }
+
+            } else if (ranktype == 5) {//优秀年级前（10名）
+                Integer linescore = lscore;
+                ERrank rr = new ERrank();
+                rr.setRanktype(ranktype);
+                rr.setLinescore(linescore);
+                String rankrange = "年级前" + linescore + "名";
+                rr.setRankname(rankrange);
+                if ("zf".equals(subjectid)) {
+                    //总分统计
+                    rr.setSubjectid("zf");
+                    rrankList.add(rr);
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setNjqTj(examid, userMap, rclassRankList, rr, rankrange, classid, subjectid, list);
+                    }
+                } else {
+                    //分科统计
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    rrank.setRankname(rankrange);
+                    rrank.setLinescore(linescore);
+                    rrank.setSubjectid(subjectid);
+                    rrankList.add(rrank);
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    setNjqTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        setNjqTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+                    }
+                }
+            } else if (ranktype == 6) {//学困年级后（10名）
+                Integer linescore = lscore;
+                ERrank rr = new ERrank();
+                rr.setRanktype(ranktype);
+                rr.setLinescore(linescore);
+                String rankrange = "年级后" + linescore + "名";
+                rr.setRankname(rankrange);
+                if ("zf".equals(subjectid)) {
+                    //总分统计
+                    rr.setSubjectid("zf");
+                    rrankList.add(rr);
+                    for (Map.Entry<Integer, List<ERstudent>> entry : zfcollect.entrySet()) {
+                        Integer classid = entry.getKey();
+                        List<ERstudent> list = entry.getValue();
+                        setNjqTj(examid, userMap, rclassRankList, rr, rankrange, classid, subjectid, list);
+                    }
+                } else {
+                    //分科统计
+                    ERrank rrank = new ERrank();
+                    rrank.setRanktype(ranktype);
+                    rrank.setRankname(rankrange);
+                    rrank.setLinescore(linescore);
+                    rrank.setSubjectid(subjectid);
+                    rrankList.add(rrank);
+                    //全部班级统计
+                    Integer classid = 0;
+                    List<ERstudent> list = qbbjcollect.get(subjectid);
+                    rrank.setMaxscore(getMaxScore(list, linescore));
+                    setNjhTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+
+                    //班级科目统计
+                    Map<Integer, List<ERstudent>> ccollect = students.stream().filter(s -> s.getSubjectid().equals(subjectid))
+                            .collect(Collectors.groupingBy(s -> s.getClassid()));
+                    for (Map.Entry<Integer, List<ERstudent>> entry : ccollect.entrySet()) {
+                        classid = entry.getKey();
+                        list = entry.getValue();
+                        rrank.setMaxscore(getMaxScore(list, linescore));
+                        setNjhTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
+                    }
+                    rrank.setMaxscore(null);
+                }
+            }
+        }
+
+        int timestamp = N_Utils.getSecondTimestamp();
+        rrankList.forEach(r -> {
+            r.setExamid(examid);
+            r.setCreateid(createid);
+            r.setCreatetime(timestamp);
+        });
+        eRrankMapper.insertList(rrankList);
+        eRclassRankMapper.insertList(rclassRankList);
+    }
+
     //获取最高分
     private Double getMaxScore(List<ERstudent> cstudents, Integer linescore) {
         List<Double> cScore = cstudents.stream().map(s -> s.getScore()).distinct().sorted().collect(Collectors.toList());

sexam/src/main/java/com/xhkjedu/sexam/service/report/EReportSchoolService.java

 package com.xhkjedu.sexam.service.report;
 
-import com.xhkjedu.sexam.mapper.paperstudent.EPaperStudentMapper;
 import com.xhkjedu.sexam.mapper.report.ERbaseMapper;
 import com.xhkjedu.sexam.mapper.report.EReportSchoolMapper;
 import com.xhkjedu.sexam.mapper.report.ERsubjectMapper;
 import com.xhkjedu.sexam.mapper.reportclass.ERclassMapper;
 import com.xhkjedu.sexam.mapper.reportclass.ERclassRankMapper;
 import com.xhkjedu.sexam.mapper.reportstu.ERstudentMapper;
-import com.xhkjedu.sexam.mapper.system.UserMapper;
 import com.xhkjedu.sexam.model.reportstu.ERstudent;
 import com.xhkjedu.sexam.model.reportstu.ERstudentAction;
-import com.xhkjedu.sexam.vo.report.ERPaperVo;
 import com.xhkjedu.sexam.vo.report.ERankParamVo;
-import com.xhkjedu.sexam.vo.system.UserVo;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
     private EReportGenerateService eReportGenerateService;
     @Resource
     private EReportSchoolMapper eReportSchoolMapper;
-    @Resource
-    private EPaperStudentMapper ePaperStudentMapper;
-    @Resource
-    private UserMapper userMapper;
 
     //考试概况
     public Map getKsGk(Integer examid) {
         Integer createid = rank.getCreateid();
         Integer ranktype = rank.getRanktype();
         eReportSchoolMapper.delByExamAndSubjectId(examid, subjectid, ranktype);//删除考试等级报告
-        List<ERPaperVo> papers = eReportSchoolMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷
-        List<ERstudent> students = ePaperStudentMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷学生
-        List<Integer> userids = students.stream().map(ERstudent::getStudentid).distinct().collect(Collectors.toList());
-        List<UserVo> users = userMapper.listNameByUserIds(userids);
-        Map<Integer, String> userMap = users.stream().collect(Collectors.toMap(UserVo::getUserid, UserVo::getUsername));
-        eReportGenerateService.setClassGradeRank(examid, papers, students, rank.getRranks(), createid, userMap);//生成考试等级报告
+        eReportGenerateService.setSubjectRank(examid, subjectid, createid, rank.getRranks(), ranktype);//生成考试等级报告
         return eRclassRankMapper.listByExamId(rank);//考试等级报告列表
     }
 

sexam/src/main/resources/mapper/paperstudent/EPaperStudentMapper.xml

     <!--考试试卷学生-->
     <select id="listByExamAndSubjectId" resultType="com.xhkjedu.sexam.model.reportstu.ERstudent">
         select classid,examid,subjectid,studentid,stuscore score,sstate
-        from e_paper_student where examid=#{examid} and subjectid=#{subjectid} and sstate!=0
+        from e_paper_student where examid=#{examid} and sstate!=0
+        <if test="subjectid!='zf'">
+            and subjectid=#{subjectid}
+        </if>
     </select>
 
     <!--更改单个学生试卷分值-->

sexam/src/main/resources/mapper/report/EReportGenerateMapper.xml

         where examid=#{examid} and good=1
         group by studentid, subjectid, good
     </select>
+    <!--获取试卷分数-->
+    <select id="getScoreByExamAndSubjectId" resultType="java.lang.Double">
+        select sum(ep.pscore) from e_paper ep where ep.examid=#{examid}
+        <if test="subjectid!='zf'">
+            and ep.subjectid=#{subjectid}
+        </if>
+    </select>
 </mapper>

sexam/src/main/resources/mapper/report/EReportSchoolMapper.xml

 <?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.sexam.mapper.report.EReportSchoolMapper">
-    <!--考试试卷-->
-    <select id="listByExamAndSubjectId" resultType="com.xhkjedu.sexam.vo.report.ERPaperVo">
-        select ep.subjectid,ep.pscore from e_paper ep where ep.examid=#{examid} and subjectid=#{subjectid}
-    </select>
     <!--删除考试等级报告-->
     <delete id="delByExamAndSubjectId">
         delete from e_rclass_rank where examid=#{examid} and subjectid=#{subjectid} and ranktype=#{ranktype};