班级报告

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.reportstu.ERstudent;
 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;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * @author ywx
     private EReportSchoolMapper eReportSchoolMapper;
     @Resource
     private EPaperStudentMapper ePaperStudentMapper;
+    @Resource
+    private UserMapper userMapper;
 
     //考试概况-学科成绩
     public List<Map> listXkCj(Integer examid, Integer classid) {
         eReportSchoolMapper.delByExamAndSubjectId(examid, subjectid, ranktype);//删除考试等级报告
         List<ERPaperVo> papers = eReportSchoolMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷
         List<ERstudent> students = ePaperStudentMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷学生
-        eReportGenerateService.setClassGradeRank(examid, papers, students, rank.getRranks(), createid);//生成考试等级报告
+        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);//生成考试等级报告
         return eRclassRankMapper.listByExamId(rank);//考试等级报告列表
     }
 

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

         eRstudentMapper.insertList(classSubjectStudents);
 
 //        setClassQuestion(examid, subjects, classes);//题型试题
-        setClassGradeRankAll(examid, papers, classSubjectStudents, createid);//班级等级分布
-        setAction(examid, subjectMap);//行为分析
+        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));
+        setClassGradeRankAll(examid, papers, classSubjectStudents, createid, userMap);//班级等级分布
+        setAction(examid, subjectMap, userMap);//行为分析
     }
 
     //班级科目平均分排名
     }
 
     //行为分析
-    private void setAction(Integer examid, Map<String, String> subjectMap) {
+    private void setAction(Integer examid, Map<String, String> subjectMap, Map<Integer, String> userMap) {
         List<ERstudentAction> studentActions = new ArrayList<>();
         List<ERclassAction> classActions = new ArrayList<>();
         //违纪行为
         List<Map> bads = eReportGenerateMapper.listBadActionByExamId(examid);
         Integer actiontype = 1;
-        setActions(examid, subjectMap, studentActions, classActions, bads, actiontype);
+        setActions(examid, subjectMap, studentActions, classActions, bads, actiontype, userMap);
         List<Map> goods = eReportGenerateMapper.listGoodActionByExamId(examid);
         actiontype = 2;
-        setActions(examid, subjectMap, studentActions, classActions, goods, actiontype);
+        setActions(examid, subjectMap, studentActions, classActions, goods, actiontype, userMap);
         if (N_Utils.isListEmpty(studentActions)) return;
         eRstudentActionMapper.insertList(studentActions);
         eRclassActionMapper.insertList(classActions);
     //处理行为数据
     private void setActions(Integer examid, Map<String, String> subjectMap
             , List<ERstudentAction> studentActions, List<ERclassAction> classActions
-            , List<Map> actions, Integer actiontype) {
+            , List<Map> actions, Integer actiontype, Map<Integer, String> userMap) {
         if (N_Utils.isListNotEmpty(actions)) {
             for (Map action : actions) {
                 action.put("subjectname", subjectMap.get(action.get("subjectid")));
             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()));
+                int znum = entry.getValue().size();//总人数
                 for (Map.Entry<String, List<Map>> sentry : scollect.entrySet()) {
                     List<Map> list = sentry.getValue();
                     Map subject = new HashMap();
                     subject.put("subjectid", sentry.getKey());
                     subject.put("subjectname", list.get(0).get("subjectname"));
-                    subject.put("num", list.size());
+                    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", userMap.get(studentid));
+                        students.add(stu);
+                    }
+                    subject.put("students", students);
                     subjects.add(subject);
                 }
                 ERclassAction ca = new ERclassAction();
     }
 
     //班级等级分布
-    private void setClassGradeRankAll(Integer examid, List<ERPaperVo> papers, List<ERstudent> students, Integer createid) {
-        setClassGradeRank(examid, papers, students, setRrank(1), createid);//班级等级分布--等级
-        setClassGradeRank(examid, papers, students, setRrank(2), createid);//班级等级分布--分数段
-        setClassGradeRank(examid, papers, students, setRrank(3), createid);//班级等级分布--临界分
-        setClassGradeRank(examid, papers, students, setRrank(4), createid);//班级等级分布--临界名次
-        setClassGradeRank(examid, papers, students, setRrank(5), createid);//班级等级分布--优秀年级前
-        setClassGradeRank(examid, papers, students, setRrank(6), createid);//班级等级分布--学困年级后
+    private void setClassGradeRankAll(Integer examid, List<ERPaperVo> papers, List<ERstudent> students
+            , Integer createid, Map<Integer, String> userMap) {
+        setClassGradeRank(examid, papers, students, setRrank(1), createid, userMap);//班级等级分布--等级
+        setClassGradeRank(examid, papers, students, setRrank(2), createid, userMap);//班级等级分布--分数段
+        setClassGradeRank(examid, papers, students, setRrank(3), createid, userMap);//班级等级分布--临界分
+        setClassGradeRank(examid, papers, students, setRrank(4), createid, userMap);//班级等级分布--临界名次
+        setClassGradeRank(examid, papers, students, setRrank(5), createid, userMap);//班级等级分布--优秀年级前
+        setClassGradeRank(examid, papers, students, setRrank(6), createid, userMap);//班级等级分布--学困年级后
     }
 
     //等级初始值设置
 
     //班级等级分布
     public void setClassGradeRank(Integer examid, List<ERPaperVo> papers, List<ERstudent> students
-            , List<ERrank> rranks, Integer createid) {
-        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<ERrank> rranks, Integer createid, Map<Integer, String> userMap) {
         Map<String, Double> scoreMap = papers.stream().collect(Collectors.toMap(p -> p.getSubjectid(), p -> p.getPscore()));//考试总分
         Double pscore;//试卷总分
 
                     }
 
                     //全部班级统计
-                    for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                        Integer classid = 0;
-                        List<ERstudent> list = entry.getValue();
-                        setDjTj(examid, userMap, rclassRankList, rrank, rankrange, subjectid, classid, list);
-                        IntSummaryStatistics statistics = list.stream().mapToInt(s -> s.getSchoolrank()).summaryStatistics();
-                        rrank1.setLinescore(statistics.getMax());
-                        rrank1.setFloatscore(statistics.getMin());
-                    }
+                    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();
+                    rrank1.setLinescore(statistics.getMax());
+                    rrank1.setFloatscore(statistics.getMin());
                     rrankList.add(rrank1);
 
                     //班级科目统计
                     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()) {
-                        Integer classid = entry.getKey();
-                        List<ERstudent> list = entry.getValue();
+                        classid = entry.getKey();
+                        list = entry.getValue();
                         setDjTj(examid, userMap, rclassRankList, rrank, rankrange, subjectid, classid, list);
                     }
                 }
                 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);
                     rrankList.add(rrank1);
 
                     //全部班级统计
-                    for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                        Integer classid = 0;
-                        List<ERstudent> list = entry.getValue();
-                        setFdTj(examid, userMap, rclassRankList, cnum, i, rrank, rankrange, classid, list);
-                    }
+                    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()) {
-                        Integer classid = entry.getKey();
-                        List<ERstudent> list = entry.getValue();
+                        classid = entry.getKey();
+                        list = entry.getValue();
                         setFdTj(examid, userMap, rclassRankList, cnum, i, rrank, rankrange, classid, list);
                     }
                 }
                 rrankList.add(rrank1);
 
                 //全部班级统计
-                for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                    Integer classid = 0;
-                    List<ERstudent> list = entry.getValue();
-                    setLjfTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
-                }
+                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()) {
-                    Integer classid = entry.getKey();
-                    List<ERstudent> list = entry.getValue();
+                    classid = entry.getKey();
+                    list = entry.getValue();
                     setLjfTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
                 }
             }
                 rrankList.add(rrank1);
 
                 //全部班级统计
-                for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                    Integer classid = 0;
-                    List<ERstudent> list = entry.getValue();
-                    setLjmcTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
-                }
+                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()) {
-                    Integer classid = entry.getKey();
-                    List<ERstudent> list = entry.getValue();
+                    classid = entry.getKey();
+                    list = entry.getValue();
                     setLjmcTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
                 }
             }
                 BeanUtils.copyProperties(rrank, rrank1);
                 rrankList.add(rrank1);
                 //全部班级统计
-                for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                    Integer classid = 0;
-                    List<ERstudent> list = entry.getValue();
-                    setNjqTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
-                }
+                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()) {
-                    Integer classid = entry.getKey();
-                    List<ERstudent> list = entry.getValue();
+                    classid = entry.getKey();
+                    list = entry.getValue();
                     setNjqTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
                 }
             }
                 rrank.setSubjectid(subjectid);
                 ERrank rrank1 = new ERrank();
                 BeanUtils.copyProperties(rrank, rrank1);
+                rrank1.setMaxscore(null);
                 rrankList.add(rrank1);
                 //全部班级统计
-                for (Map.Entry<String, List<ERstudent>> entry : qbbjcollect.entrySet()) {
-                    Integer classid = 0;
-                    List<ERstudent> list = entry.getValue();
-                    rrank.setMaxscore(getMaxScore(list, linescore));
-                    setNjhTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
-                }
+                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()) {
-                    Integer classid = entry.getKey();
-                    List<ERstudent> list = entry.getValue();
+                    classid = entry.getKey();
+                    list = entry.getValue();
                     rrank.setMaxscore(getMaxScore(list, linescore));
                     setNjhTj(examid, userMap, rclassRankList, rrank, rankrange, classid, subjectid, list);
                 }
         ERclassRank gr = new ERclassRank();
         gr.setExamid(examid);
         gr.setClassid(classid);
+        gr.setSubjectid(rrank.getSubjectid());
         gr.setRanktype(rrank.getRanktype());
         gr.setRankname(rrank.getRankname());
         List<ERstudent> list2;
         cr.setRanktype(rrank.getRanktype());
         cr.setRankname(rankname);
         List<ERstudent> list2;
-        double finalMinscore = rrank.getMaxscore();
-        double finalMaxscore = rrank.getMinscore();
+        double finalMinscore = rrank.getMinscore();
+        double finalMaxscore = rrank.getMaxscore();
         if (rankname.equals("A")) {
             list2 = list.stream().filter(s -> s.getScore().compareTo(finalMinscore) != -1).collect(Collectors.toList());
         } else {

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

 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 EReportSchoolMapper eReportSchoolMapper;
     @Resource
     private EPaperStudentMapper ePaperStudentMapper;
+    @Resource
+    private UserMapper userMapper;
 
     //考试概况
     public Map getKsGk(Integer examid) {
         eReportSchoolMapper.delByExamAndSubjectId(examid, subjectid, ranktype);//删除考试等级报告
         List<ERPaperVo> papers = eReportSchoolMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷
         List<ERstudent> students = ePaperStudentMapper.listByExamAndSubjectId(examid, subjectid);//考试试卷学生
-        eReportGenerateService.setClassGradeRank(examid, papers, students, rank.getRranks(), createid);//生成考试等级报告
+        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);//生成考试等级报告
         return eRclassRankMapper.listByExamId(rank);//考试等级报告列表
     }