优化学生报告

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

 package com.xhkjedu.sexam.service.report;
 
+import ch.qos.logback.core.net.SyslogOutputStream;
 import com.alibaba.fastjson.JSON;
 import com.xhkjedu.sexam.mapper.exam.EClassMapper;
 import com.xhkjedu.sexam.mapper.paper.EPaperAnalyzeMapper;
     private void setClassQuestion(Integer examid, List<Map> subjects, List<Map> classes) {
         //考试所有学生提交试卷作答情况
         List<EPaperStudentQuestion> stulist = ePaperStudentQuestionMapper.listExamStudentsAnswer(examid);
-
         List<ERclassQtype> rtypelist = new ArrayList<>();//班级题型
         List<ERStudentQtype> stutypelist = new ArrayList<>();//学生题型
         List<ERclassQuestion> rqueslist = new ArrayList<>();//班级试题
 
             if (ptype == 1) {
                 //处理题型下试题：题库显示题号时为母题的题号即order（qn是英语为顺延题号其他学科为母题号和子题排序拼接）
-//                String qtypejson = panalyze.get("qnumjson").toString();//原试卷题型分析
-//                List<Map> qtypelist = JSON.parseArray(qtypejson, Map.class);
-//                setPaperQuestionTkQtypes(qtypelist, paperstulist, rtypelist, rqueslist, stutypelist, examPaperClassVo);
+                String qtypejson = panalyze.get("qnumjson").toString();//原试卷题型分析
+                List<Map> qtypelist = JSON.parseArray(qtypejson, Map.class);
+                setPaperQuestionTkQtypes(qtypelist, paperstulist, rtypelist, rqueslist, stutypelist, examPaperClassVo);
 
                 //处理知识点
-//                setEPaperQuestionPoints(panalyze, paperstulist, rpointlist, stupointlist, examPaperClassVo);
+                setEPaperQuestionPoints(panalyze, paperstulist, rpointlist, stupointlist, examPaperClassVo);
 
                 //处理难易度
                 String complexityjson = panalyze.get("complexityjson").toString();
                 setPaperQuestionFjQtypes(qtypelist, paperstulist, rtypelist, rqueslist, stutypelist, examPaperClassVo);
             }
         }
-//        eRclassQtypeMapper.insertList(rtypelist);
-//        eRstudentQtypeMapper.insertList(stutypelist);
-//        eRclassQuestionMapper.insertList(rqueslist);
+
+
+        eRclassQtypeMapper.insertList(rtypelist);
+        eRstudentQtypeMapper.insertList(stutypelist);
+        eRclassQuestionMapper.insertList(rqueslist);
         eRclassComplexityMapper.insertList(complist);
         erStudentComplexityMapper.insertList(stucomplist);
-//        eRclassPointMapper.insertList(rpointlist);
-//        eRstudentPointMapper.insertList(stupointlist);
+        eRclassPointMapper.insertList(rpointlist);
+        eRstudentPointMapper.insertList(stupointlist);
     }
 
     //题型、试题、知识点、难易度--处理学生选项情况和得分情况
                     Map<Integer, List<EPaperStudentQuestion>> stuQuesMap = stuqlist.stream().collect(Collectors.groupingBy(EPaperStudentQuestion::getStudentid));
                     for (Map.Entry<Integer, List<EPaperStudentQuestion>> entry : stuQuesMap.entrySet()) {
                         List<EPaperStudentQuestion> stuqueslist = entry.getValue();
-                        EPaperStudentQuestion pstq = stuqueslist.get(0);
+                        EPaperStudentQuestion pfist = stuqueslist.get(0);
+                        EPaperStudentQuestion pstq = new EPaperStudentQuestion();
+                        pstq.setClassid(pfist.getClassid());
+                        pstq.setStudentid(entry.getKey());
+
                         Double qstuscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
                         Double qscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
                         pstq.setQscore(qscore);
                     for(Map.Entry<Integer,List<EPaperStudentQuestion>> entry : stuquesmap.entrySet()){
                         List<EPaperStudentQuestion> stuques = entry.getValue();
                         Double stuscore = stuques.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                        EPaperStudentQuestion sq = stuques.get(0);
+                        EPaperStudentQuestion sqfirst = stuques.get(0);
+                        EPaperStudentQuestion sq = new EPaperStudentQuestion();
+                        sq.setStudentid(entry.getKey());
+                        sq.setClassid(sqfirst.getClassid());
                         sq.setStuscore(stuscore);
                         setEPaperQuestionPointsForStuQues(gradestulist,sq,points,eptqidsStr);
                     }
             for(Map.Entry<Integer,List<ERPointStuScoreVo>> entry : pointstuscoremap.entrySet()){
                 List<ERPointStuScoreVo> stuscorelist = entry.getValue();
                 Double stuscore = stuscorelist.stream().mapToDouble(ERPointStuScoreVo::getStuscore).sum();
-//                Double qscore = stuscorelist.stream().mapToDouble(ERPointStuScoreVo::getScore).sum();
-                ERPointStuScoreVo sscorevo = stuscorelist.get(0);
+                ERPointStuScoreVo sscorevofirst = stuscorelist.get(0);
+                ERPointStuScoreVo sscorevo = new ERPointStuScoreVo();
+                sscorevo.setStudentid(sscorevofirst.getStudentid());
+                sscorevo.setClassid(sscorevofirst.getClassid());
                 sscorevo.setStuscore(stuscore);
-//                sscorevo.setScore(qscore);
                 pointstuscorelist.add(sscorevo);
             }
 
             List<Map> queslist = (List<Map>) compmap.get("ques");//试题相关对象（数量为几个代表几个母题）
 
             String qns = "";
-            Double tgstuscore = 0.0;//难易度下学生得分
-            Double tgscore = 0.0;//难易度下试题总分
-            Map<Integer, ERClassScoreVo> tclassmap = new HashMap<>();
-            Map<Integer, ERStudentComplexity> tstumap = new HashMap<>();
-
+            List<Integer> leveleptqids = new ArrayList<>();//所有试题id
             for (Map quesmap : queslist) {
                 List<Integer> eptqids = (List<Integer>) quesmap.get("eptqids");
-                Integer qlevel = Integer.parseInt(quesmap.get("qlevel").toString());
                 String order = quesmap.get("order").toString();//试题母题题号
                 qns = qns + order + ",";
+                leveleptqids.addAll(eptqids);
+            }
 
-                //获取集合中对应子题集合的数据
-                List<EPaperStudentQuestion> qgstulist = null;
-                if (qlevel == 1) {
-                    //该题未单题
-                    qgstulist = paperstulist.stream().filter(s -> s.getEptqid().equals(eptqids.get(0))).collect(Collectors.toList());
-                } else {
-                    //该题未复合型试题
-                    qgstulist = new ArrayList<>();
-                    List<EPaperStudentQuestion> stuquelist = paperstulist.stream().filter(s -> eptqids.contains(s.getEptqid())).collect(Collectors.toList());
-                    //母子题情况，计算所有子题的和即为母题。把试题按照学生分组，分组为一组的即为
-                    Map<Integer, List<EPaperStudentQuestion>> stuQuesMap = stuquelist.stream().collect(Collectors.groupingBy(EPaperStudentQuestion::getStudentid));
-                    for (Map.Entry<Integer, List<EPaperStudentQuestion>> entry : stuQuesMap.entrySet()) {
-                        List<EPaperStudentQuestion> stuqueslist = entry.getValue();
-                        EPaperStudentQuestion pstq = stuqueslist.get(0);
-                        Double qstuscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                        Double qscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
-                        pstq.setQscore(qscore);
-                        pstq.setStuscore(qstuscore);
-                        qgstulist.add(pstq);
-                    }
-                }
-                Double qgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
-                Double qgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                tgscore = ExamUtil.add(tgscore, qgscore);
-                tgstuscore = ExamUtil.add(tgstuscore, qgstuscore);
-
-                for (Map classm : classes) {
-                    Integer classid = Integer.parseInt(classm.get("classid").toString());
-                    List<EPaperStudentQuestion> qcstulist = qgstulist.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
-                    int cstunum = qcstulist.size();//班级下试题作答学生数量
-                    Double qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
-                    Double qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-
-                    if (tclassmap.containsKey(classid)) {
-                        ERClassScoreVo erClassScoreVo = tclassmap.get(classid);
-                        erClassScoreVo.setStuscore(ExamUtil.add(erClassScoreVo.getStuscore(), qcstuscore));
-                        erClassScoreVo.setCscore(ExamUtil.add(erClassScoreVo.getCscore(), qcscore));
-                    } else {
-                        ERClassScoreVo erClassScoreVo = new ERClassScoreVo();
-                        erClassScoreVo.setStunum(cstunum);
-                        erClassScoreVo.setStuscore(qcstuscore);
-                        erClassScoreVo.setCscore(qcscore);
-                        tclassmap.put(classid, erClassScoreVo);
-                    }
+            List<EPaperStudentQuestion> levelstuquelist = new ArrayList<>();//难易度下所有试题
+            for(Integer eptqid : leveleptqids){
+               List<EPaperStudentQuestion> petqqueslit = paperstulist.stream().filter(s -> eptqid.equals(s.getEptqid())).collect(Collectors.toList());
+               levelstuquelist.addAll(petqqueslit);
+            }
 
-                    for (EPaperStudentQuestion q : qcstulist) {
-                        if (tstumap.containsKey(q.getStudentid())) {
-                            ERStudentComplexity sq = tstumap.get(q.getStudentid());
-                            sq.setStuscore(ExamUtil.add(sq.getStuscore(), q.getStuscore()));
-                        } else {
-                            ERStudentComplexity sq = new ERStudentComplexity();
-                            sq.setClassid(q.getClassid());
-                            sq.setStudentid(q.getStudentid());
-                            sq.setStuscore(q.getStuscore());
-                            tstumap.put(q.getStudentid(),sq);
-                        }
-                    }
-                }
+            List<EPaperStudentQuestion> qgstulist = new ArrayList<>();//每个学生难易度下得分
+            Map<Integer, List<EPaperStudentQuestion>> stuQuesMap = levelstuquelist.stream().collect(Collectors.groupingBy(EPaperStudentQuestion::getStudentid));
+            for (Map.Entry<Integer, List<EPaperStudentQuestion>> entry : stuQuesMap.entrySet()) {
+                List<EPaperStudentQuestion> stuqueslist = entry.getValue();
+                EPaperStudentQuestion pfirst = stuqueslist.get(0);
+                EPaperStudentQuestion pstq = new EPaperStudentQuestion();
+                pstq.setStudentid(entry.getKey());
+                pstq.setClassid(pfirst.getClassid());
+                Double qstuscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                Double qscore = stuqueslist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                pstq.setQscore(qscore);
+                pstq.setStuscore(qstuscore);
+                qgstulist.add(pstq);
+
+                ERStudentComplexity stucomp = new ERStudentComplexity();
+                stucomp.setStudentid(entry.getKey());
+                stucomp.setClassid(pstq.getClassid());
+                stucomp.setExamid(examPaperClassVo.getExamid());
+                stucomp.setSubjectid(examPaperClassVo.getSubjectid());
+                stucomp.setEpid(examPaperClassVo.getEpid());
+                stucomp.setComplexity(complexity);
+                stucomp.setStuscore(qstuscore);
+                stucomp.setStusrate(N_Utils.getDoubleDivideAndMulitiply(qstuscore, qscore));
+                stucomplist.add(stucomp);
             }
 
+            Double tgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion :: getStuscore).sum();//难易度下学生得分
+            Double tgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion :: getQscore).sum();//难易度下试题总分
             Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore, tgscore);//年级得分率
 
-            //难易度--班级得分
-            for (Map.Entry<Integer, ERClassScoreVo> entry : tclassmap.entrySet()) {
-                ERClassScoreVo erClassScoreVo = entry.getValue();
+            for (Map classm : classes) {
+                Integer classid = Integer.parseInt(classm.get("classid").toString());
+                List<EPaperStudentQuestion> qcstulist = qgstulist.stream().filter(s -> s.getClassid().equals(classid)).collect(Collectors.toList());
+                Double qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                Double qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+
                 ERclassComplexity erc = new ERclassComplexity();
                 erc.setExamid(examPaperClassVo.getExamid());
                 erc.setSubjectid(examPaperClassVo.getSubjectid());
                 erc.setEpid(examPaperClassVo.getEpid());
-                erc.setClassid(entry.getKey());
+                erc.setClassid(classid);
                 erc.setComplexity(complexity);
                 erc.setScore(score);
                 erc.setSrate(srate);
                 erc.setGradescore(tgstuscore);
                 erc.setGradesrate(tgsrate);
-                erc.setClassscore(erClassScoreVo.getStuscore());
-                erc.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getStuscore(), erClassScoreVo.getCscore()));
+                erc.setClassscore(qcstuscore);
+                erc.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(qcstuscore, qcscore));
                 erc.setQns(qns.substring(0, qns.lastIndexOf(",")));
                 complist.add(erc);
             }
-            //难易度--学生得分
-            for (Map.Entry<Integer, ERStudentComplexity> entry : tstumap.entrySet()) {
-                ERStudentComplexity stucomp = entry.getValue();
-                stucomp.setExamid(examPaperClassVo.getExamid());
-                stucomp.setSubjectid(examPaperClassVo.getSubjectid());
-                stucomp.setEpid(examPaperClassVo.getEpid());
-                stucomp.setComplexity(complexity);
-                stucomp.setStusrate(N_Utils.getDoubleDivideAndMulitiply(stucomp.getStuscore(), score));
-                stucomplist.add(stucomp);
-            }
         }
     }
 }

sexam/src/test/java/com/xhkjedu/sexam/SexamApplicationTests.java

 package com.xhkjedu.sexam;
 
-import com.xhkjedu.sexam.model.paper.EPaper;
-import com.xhkjedu.sexam.model.paper.EPaperQtype;
-import com.xhkjedu.sexam.model.paper.EPaperQtypeQuestion;
-import com.xhkjedu.sexam.service.paper.EPaperQtypeService;
 import org.junit.jupiter.api.Test;
 import org.springframework.boot.test.context.SpringBootTest;
-
-import javax.annotation.Resource;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
 @SpringBootTest
 class SexamApplicationTests {