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

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

 import com.xhkjedu.smarking.vo.report.reportstu.PointQuestionVo;
 import com.xhkjedu.smarking.vo.report.reportstu.PointStudentVo;
 import com.xhkjedu.smarking.vo.report.reportsubject.PointLevelVo;
+import com.xhkjedu.smarking.vo.report.reportsubject.PointParams;
 import com.xhkjedu.smarking.vo.report.reportsubject.PointVo;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
 
         //学科总分区间学生
         List<MsrSubjectPointSection> pointSections = setPointSection(sturanks,pscore);
+        Map<Integer,String> qnMap = qtypeQuestions.stream().collect(Collectors.toMap(q-> q.getMptqid(), q -> q.getMptqn() + "." + q.getQn()));
 
-        // 根据试卷知识点分析进行生成学生、年级知识点分析
-        for (PointQuestionVo pqvo : pointques){
+        //知识点本分分析（三级知识点分析）
+        for(PointQuestionVo pqvo : pointques){
             List<QuestionPointVo> quePoints = pqvo.getQues();//知识点下试题
-            //获取所有试题的mptqids
-            List<Integer> mptqids = new ArrayList<>();
-            for(QuestionPointVo qpv : quePoints){
-                mptqids.addAll(qpv.getMptqids());
-            }
-            //获取试题对应的qn
-            List<MsPaperQtypeQuestion> qtypeQues =  qtypeQuestions.stream().filter(q -> mptqids.contains(q.getMptqid())).collect(Collectors.toList());
-            String qnStr = qtypeQues.stream().map(q -> q.getMptqn()  + "." + q.getQn()).collect(Collectors.joining(","));
-            String mptqidStr = mptqids.stream().map(Object::toString).collect(Collectors.joining(","));
             // 单个知识点学生得分情况:一个知识对应一个或多个试题，
             List<PointStudentVo> stuPoints = schoolStuPoints.stream().filter(ps -> ps.getPointid().equals(pqvo.getPointid())).collect(Collectors.toList());
-            //知识点下多个试题，处理成单个学生总分值情况
-            List<PointStudentVo> pointStuScores = new ArrayList<>();//处理成学生知识点形式，后续计算使用
-            Map<Integer, List<PointStudentVo>> pointStuMap = stuPoints.stream().collect(Collectors.groupingBy(PointStudentVo::getStudentid));
-            for (Map.Entry<Integer, List<PointStudentVo>> entry : pointStuMap.entrySet()){
-                List<PointStudentVo> pstuScores = entry.getValue();
-                Double stuScore = pstuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
-                stuScore = N_Utils.formatDouble(stuScore, 1);
-                PointStudentVo firstPointStuVo = pstuScores.get(0);
-                PointStudentVo pstuvo = new PointStudentVo();
-                pstuvo.setStudentid(entry.getKey());
-                pstuvo.setPointid(firstPointStuVo.getPointid());
-                pstuvo.setStuscore(stuScore);
-                pstuvo.setScore(firstPointStuVo.getScore());
-                pointStuScores.add(pstuvo);
-            }
-
-            MsrSubjectPoint subjectPoint = new MsrSubjectPoint();
-            subjectPoint.setExamid(examid);
-            subjectPoint.setSubjectid(subjectid);
-            subjectPoint.setPointid(pqvo.getPointid());
-            subjectPoint.setClassid(0);
-            subjectPoint.setPointname(pqvo.getPointname());
-            subjectPoint.setFullscore(pqvo.getScore());
-            subjectPoint.setPointlevel(3);//3级知识点分析
-            subjectPoint.setMptqids(mptqidStr);
-            subjectPoint.setQns(qnStr);
-
-            //校知识点分析
-            MsrSubjectPoint schoolPoint = pointLevelClass(pointStuScores, subjectPoint);
-            saveSubjectPoints.add(schoolPoint);
-
-            //班级知识点分析
-            List<Integer> classIds = classStus.stream().map(MsClassStudent::getClassid).distinct().collect(Collectors.toList());
-            List<MsrSubjectPoint> classPoints = new ArrayList<>();
-            for (Integer classid : classIds) {
-                // 获取班级下学生id
-                List<Integer> classStuIds = classStus.stream().filter(c -> c.getClassid().equals(classid)).map(MsClassStudent::getStudentid).collect(Collectors.toList());
-                // 获取班级下学生试题
-                List<PointStudentVo> classStuPoints = pointStuScores.stream().filter(q -> classStuIds.contains(q.getStudentid())).collect(Collectors.toList());
-                subjectPoint.setClassid(classid);
-                MsrSubjectPoint classPoint = pointLevelClass(classStuPoints, subjectPoint);
-                classPoints.add(classPoint);
-            }
-
-            // 班级知识点保存后，要对平均分排序
-            List<Double> avgScores = classPoints.stream().map(MsrSubjectPoint::getAvgscore).collect(Collectors.toList());
-            Map<Double,Integer> avgScoreRankMap = MarkingUtil.fspm(avgScores);
-            for(MsrSubjectPoint sp : classPoints){
-                sp.setAvgrank(avgScoreRankMap.get(sp.getAvgscore()));
-            }
-            saveSubjectPoints.addAll(classPoints);
 
-            //知识点结构与总分的相关性(三级知识点)
-            List<MsrSubjectPointSection> pointSecs = pointSection(pointStuScores, pointSections, pqvo, 3);
-            savePointSections.addAll(pointSecs);
+            PointParams pointParams = new PointParams();
+            pointParams.setPointid(pqvo.getPointid());
+            pointParams.setPointname(pqvo.getPointname());
+            pointParams.setFullscore(pqvo.getScore());
+            pointParams.setExamid(examid);
+            pointParams.setSubjectid(subjectid);
+            pointParams.setPointlevel(3);
+            //三级知识点对应信息
+            pointTopAndUpForOther(stuPoints,quePoints,qnMap,pointParams,classStus,pointSections,sturanks,saveStuPoints,saveSubjectPoints,savePointSections,savePointRankgroups);
+        }
 
-            //知识点考生分组分析
-            List<MsrSubjectPointRankgroup> pointRankg = pointRankGroup(pointStuScores,sturanks, pqvo, examid, subjectid, 3);
-            savePointRankgroups.addAll(pointRankg);
+        //获取知识点顶级和上级知识点
+        Map<String,Map<String,List<PointLevelVo>>> pointTopAndUpMap = listSubjectPoints(subjectid,examid,pointques);
+        Map<String,List<PointLevelVo>> pointUpMap = pointTopAndUpMap.get("up");//上级知识点
+        Map<String,List<PointLevelVo>> pointTopMap = pointTopAndUpMap.get("top");//顶级知识点
+        //知识点分析--三级知识点（知识点分析）
+        Map<String, List<MsrSubjectPoint>> subjectPointMap = saveSubjectPoints.stream().filter(p -> p.getPointlevel()==3).collect(Collectors.groupingBy(MsrSubjectPoint::getPointid));
+        //知识点学科总分区间--三级知识点（知识点分析）
+        Map<String, List<MsrSubjectPointSection>> pointSectionMap = savePointSections.stream().filter(p -> p.getPointlevel()==3).collect(Collectors.groupingBy(MsrSubjectPointSection::getPointid));
+        //知识点分组--三级知识点（知识点分析）
+        Map<String, List<MsrSubjectPointRankgroup>> pointRankgroupMap = savePointRankgroups.stream().filter(p -> p.getPointlevel()==3).collect(Collectors.groupingBy(MsrSubjectPointRankgroup::getPointid));
 
-            double schoolSumScore = pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
-            int stunum = pointStuScores.size();
-            double schoolAvgScore = MarkingUtil.div(schoolSumScore, stunum);
-            double schoolScoreRate = MarkingUtil.calculateRate(schoolSumScore, pqvo.getScore() * stunum);
+        //上层知识点（二级知识点）
+        for(Map.Entry<String,List<PointLevelVo>> entry : pointUpMap.entrySet()) {
+            List<PointLevelVo> pointLevels = entry.getValue();
+            PointLevelVo firstPoint = pointLevels.get(0);
+            if(pointLevels.size() == 1){
+                //上层知识点下知识点只有一个，该知识点的分析和三级知识点一致
+                pointTopAndUpForSelf(firstPoint,2,subjectPointMap,pointSectionMap,pointRankgroupMap,saveSubjectPoints,savePointSections,savePointRankgroups);
+            }else{
+                //上层知识点所包含的知识点id集合
+                List<String> pointids = pointLevels.stream().map(PointLevelVo::getPointid).collect(Collectors.toList());
+                //知识点下试题，以及学生得分
+                List<PointQuestionVo> levelPointQues = pointques.stream().filter(q -> pointids.contains(q.getPointid())).collect(Collectors.toList());
+                List<PointStudentVo> stuPoints = schoolStuPoints.stream().filter(q -> pointids.contains(q.getPointid())).collect(Collectors.toList());
+                List<QuestionPointVo> ques = new ArrayList<>();//知识点下所有试题
+                for(PointQuestionVo point : levelPointQues) {
+                    ques.addAll(point.getQues());
+                }
+                Double fullScore = levelPointQues.stream().mapToDouble(PointQuestionVo::getScore).sum();
+                fullScore = N_Utils.formatDouble(fullScore, 1);
+                PointParams pointParams = new PointParams();
+                pointParams.setPointid(firstPoint.getTopPointid());
+                pointParams.setPointname(firstPoint.getTopPointname());
+                pointParams.setFullscore(fullScore);
+                pointParams.setExamid(examid);
+                pointParams.setSubjectid(subjectid);
+                pointParams.setPointlevel(2);
+                //级知识点对应信息
+                pointTopAndUpForOther(stuPoints,ques,qnMap,pointParams,classStus,pointSections,sturanks,saveStuPoints,saveSubjectPoints,savePointSections,savePointRankgroups);
+            }
+        }
 
-            //处理学生得分情况
-            for(PointStudentVo pstuvo : pointStuScores){
-                MsrStudentPoint stuPoint = new MsrStudentPoint();
-                stuPoint.setExamid(examid);
-                stuPoint.setSubjectid(subjectid);
-                stuPoint.setStudentid(pstuvo.getStudentid());
-                stuPoint.setPointid(pqvo.getPointid());
-                stuPoint.setPointname(pqvo.getPointname());
-                stuPoint.setFullscore(pqvo.getScore());
-                stuPoint.setStuscore(pstuvo.getStuscore());
-                stuPoint.setSturate(MarkingUtil.calculateRate(pstuvo.getStuscore(), pqvo.getScore()));
-                stuPoint.setSchoolavg(schoolAvgScore);
-                stuPoint.setSchoolrate(schoolScoreRate);
-                stuPoint.setQns(qnStr);
-                stuPoint.setMptqid(mptqidStr);
-                saveStuPoints.add(stuPoint);
+        //顶级知识点 (一级知识点)
+        for(Map.Entry<String,List<PointLevelVo>> entry : pointTopMap.entrySet()) {
+            List<PointLevelVo> pointLevels = entry.getValue();
+            PointLevelVo firstPoint = pointLevels.get(0);
+            if(pointLevels.size() == 1){
+                //上层知识点下知识点只有一个，该知识点的分析和三级知识点一致
+                pointTopAndUpForSelf(firstPoint,1,subjectPointMap,pointSectionMap,pointRankgroupMap,saveSubjectPoints,savePointSections,savePointRankgroups);
+            }else{
+                //上层知识点所包含的知识点id集合
+                List<String> pointids = pointLevels.stream().map(PointLevelVo::getPointid).collect(Collectors.toList());
+                //知识点下试题，以及学生得分
+                List<PointQuestionVo> levelPointQues = pointques.stream().filter(q -> pointids.contains(q.getPointid())).collect(Collectors.toList());
+                List<PointStudentVo> stuPoints = schoolStuPoints.stream().filter(q -> pointids.contains(q.getPointid())).collect(Collectors.toList());
+                List<QuestionPointVo> ques = new ArrayList<>();//知识点下所有试题
+                for(PointQuestionVo point : levelPointQues) {
+                    ques.addAll(point.getQues());
+                }
+                Double fullScore = levelPointQues.stream().mapToDouble(PointQuestionVo::getScore).sum();
+                fullScore = N_Utils.formatDouble(fullScore, 1);
+                PointParams pointParams = new PointParams();
+                pointParams.setPointid(firstPoint.getTopPointid());
+                pointParams.setPointname(firstPoint.getTopPointname());
+                pointParams.setFullscore(fullScore);
+                pointParams.setExamid(examid);
+                pointParams.setSubjectid(subjectid);
+                pointParams.setPointlevel(1);
+                //级知识点对应信息
+                pointTopAndUpForOther(stuPoints,ques,qnMap,pointParams,classStus,pointSections,sturanks,saveStuPoints,saveSubjectPoints,savePointSections,savePointRankgroups);
             }
         }
     }
         return current;
     }
 
-    //处理顶级、上级知识点
+    //层级知识点分析--顶层和上层知识点是知识点本身
+    private void pointTopAndUpForSelf(PointLevelVo firstPoint,Integer pointlevel,Map<String, List<MsrSubjectPoint>> subjectPointMap,
+            Map<String, List<MsrSubjectPointSection>> pointSectionMap,Map<String, List<MsrSubjectPointRankgroup>> pointRankgroupMap,
+            List<MsrSubjectPoint> saveSubjectPoints,List<MsrSubjectPointSection> savePointSections, List<MsrSubjectPointRankgroup> savePointRankgroups){
+
+        //知识点分析
+        List<MsrSubjectPoint> subpoints = subjectPointMap.get(firstPoint.getPointid());
+        for(MsrSubjectPoint subpoint : subpoints){
+            subpoint.setPointid(firstPoint.getTopPointid());
+            subpoint.setPointname(firstPoint.getPointname());
+            subpoint.setPointlevel(pointlevel);
+            saveSubjectPoints.add(subpoint);
+        }
+
+        //分数分段
+        List<MsrSubjectPointSection> sepoints = pointSectionMap.get(firstPoint.getPointid());
+        for(MsrSubjectPointSection sepoint : sepoints) {
+            sepoint.setPointid(firstPoint.getTopPointid());
+            sepoint.setPointname(firstPoint.getPointname());
+            sepoint.setPointlevel(pointlevel);
+            savePointSections.add(sepoint);
+        }
+
+        //分组分析
+        List<MsrSubjectPointRankgroup> rgpoints = pointRankgroupMap.get(firstPoint.getPointid());
+        for(MsrSubjectPointRankgroup rgpoint : rgpoints) {
+            rgpoint.setPointid(firstPoint.getTopPointid());
+            rgpoint.setPointname(firstPoint.getPointname());
+            rgpoint.setPointlevel(pointlevel);
+            savePointRankgroups.add(rgpoint);
+        }
+    }
+    //层级知识点分析--顶层和上层知识点下多知识点分析
+    private void pointTopAndUpForOther(List<PointStudentVo> levelStuPoints, List<QuestionPointVo> ques, Map<Integer,String> qnMap, PointParams pointParam,
+                                        List<MsClassStudent> classStus, List<MsrSubjectPointSection> pointSections, List<MsrStudent> sturanks,List<MsrStudentPoint> saveStuPoints,
+                                        List<MsrSubjectPoint> saveSubjectPoints, List<MsrSubjectPointSection> savePointSections, List<MsrSubjectPointRankgroup> savePointRankgroups){
+
+        List<Integer> mptqids = ques.stream().map(QuestionPointVo::getMptqid).distinct().collect(Collectors.toList());
+        String qnStr="";
+        String mptqidStr = mptqids.stream().map(Object::toString).collect(Collectors.joining(","));
+        for(Map.Entry<Integer,String> qnentry : qnMap.entrySet()){
+            if(mptqids.contains(qnentry.getKey())){
+                qnStr = qnStr + qnentry.getValue() + ",";
+            }
+        }
+        if(N_Utils.isNotEmpty(qnStr)){
+            qnStr = qnStr.substring(0,qnStr.length()-1);
+        }
+
+        //知识点多个试题，处理成单个学生试题总分值
+        List<PointStudentVo> pointStuScores = new ArrayList<>();//处理成学生知识点形式，后续计算使用
+        Map<Integer, List<PointStudentVo>> pointStuMap = levelStuPoints.stream().collect(Collectors.groupingBy(PointStudentVo::getStudentid));
+        for (Map.Entry<Integer, List<PointStudentVo>> psentry : pointStuMap.entrySet()){
+            List<PointStudentVo> pstuScores = psentry.getValue();
+            double stuScore = pstuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+            stuScore = N_Utils.formatDouble(stuScore, 1);
+            PointStudentVo pstuvo = new PointStudentVo();
+            pstuvo.setStudentid(psentry.getKey());
+            pstuvo.setPointid(pointParam.getPointid());
+            pstuvo.setStuscore(stuScore);
+            pstuvo.setScore(pointParam.getFullscore());
+            pointStuScores.add(pstuvo);
+        }
+
+        MsrSubjectPoint subjectPoint = new MsrSubjectPoint();
+        subjectPoint.setExamid(pointParam.getExamid());
+        subjectPoint.setSubjectid(pointParam.getSubjectid());
+        subjectPoint.setPointid(pointParam.getPointid());
+        subjectPoint.setClassid(0);
+        subjectPoint.setPointname(pointParam.getPointid());
+        subjectPoint.setFullscore(pointParam.getFullscore());
+        subjectPoint.setPointlevel(pointParam.getPointlevel());
+        subjectPoint.setMptqids(mptqidStr);
+        subjectPoint.setQns(qnStr);
+
+        //校知识点分析
+        MsrSubjectPoint schoolPoint = pointLevelClass(pointStuScores, subjectPoint);
+        saveSubjectPoints.add(schoolPoint);
+
+        //班级知识点分析
+        List<Integer> classIds = classStus.stream().map(MsClassStudent::getClassid).distinct().collect(Collectors.toList());
+        List<MsrSubjectPoint> classPoints = new ArrayList<>();
+        for (Integer classid : classIds) {
+            // 获取班级下学生id
+            List<Integer> classStuIds = classStus.stream().filter(c -> c.getClassid().equals(classid)).map(MsClassStudent::getStudentid).collect(Collectors.toList());
+            // 获取班级下学生试题
+            List<PointStudentVo> classStuPoints = pointStuScores.stream().filter(q -> classStuIds.contains(q.getStudentid())).collect(Collectors.toList());
+            subjectPoint.setClassid(classid);
+            MsrSubjectPoint classPoint = pointLevelClass(classStuPoints, subjectPoint);
+            classPoints.add(classPoint);
+        }
+
+        // 班级知识点保存后，要对平均分排序
+        List<Double> avgScores = classPoints.stream().map(MsrSubjectPoint::getAvgscore).collect(Collectors.toList());
+        Map<Double,Integer> avgScoreRankMap = MarkingUtil.fspm(avgScores);
+        for(MsrSubjectPoint sp : classPoints){
+            sp.setAvgrank(avgScoreRankMap.get(sp.getAvgscore()));
+        }
+        saveSubjectPoints.addAll(classPoints);
+
+        PointQuestionVo pqvo = new PointQuestionVo();
+        pqvo.setPointid(pointParam.getPointid());
+        pqvo.setPointname(pointParam.getPointname());
+        pqvo.setScore(pointParam.getFullscore());
+
+        //知识点分段分析(知识点与总分的相关性)
+        List<MsrSubjectPointSection> pointSecs = pointSection(pointStuScores, pointSections, pqvo, pointParam.getPointlevel());
+        savePointSections.addAll(pointSecs);
+
+        //知识点考生分组分析
+        List<MsrSubjectPointRankgroup> pointRankg = pointRankGroup(pointStuScores,sturanks, pqvo, pointParam.getExamid(), pointParam.getSubjectid(), pointParam.getPointlevel());
+        savePointRankgroups.addAll(pointRankg);
+
+        if(pointParam.getPointlevel() == 3){
+            double schoolSumScore = pointStuScores.stream().mapToDouble(PointStudentVo::getStuscore).sum();
+            int stunum = pointStuScores.size();
+            double schoolAvgScore = MarkingUtil.div(schoolSumScore, stunum);
+            double schoolScoreRate = MarkingUtil.calculateRate(schoolSumScore, pqvo.getScore() * stunum);
+            //处理学生得分情况
+            for(PointStudentVo pstuvo : pointStuScores){
+                MsrStudentPoint stuPoint = new MsrStudentPoint();
+                stuPoint.setExamid(pointParam.getExamid());
+                stuPoint.setSubjectid(pointParam.getSubjectid());
+                stuPoint.setStudentid(pstuvo.getStudentid());
+                stuPoint.setPointid(pqvo.getPointid());
+                stuPoint.setPointname(pqvo.getPointname());
+                stuPoint.setFullscore(pqvo.getScore());
+                stuPoint.setStuscore(pstuvo.getStuscore());
+                stuPoint.setSturate(MarkingUtil.calculateRate(pstuvo.getStuscore(), pqvo.getScore()));
+                stuPoint.setSchoolavg(schoolAvgScore);
+                stuPoint.setSchoolrate(schoolScoreRate);
+                stuPoint.setQns(qnStr);
+                stuPoint.setMptqid(mptqidStr);
+                saveStuPoints.add(stuPoint);
+            }
+        }
+
+    }
+    //处理顶级、上级知识点---已不用
     private void handlePointLevel(Map<String,List<PointLevelVo>> pointMap,List<PointQuestionVo> pointques,List<PointStudentVo> schoolStuPoints,Integer pointlevel,List<MsrSubjectPointSection> pointSections,
                                     List<MsPaperQtypeQuestion> qtypeQuestions,List<MsClassStudent> classStus,Integer examid,String subjectid,List<MsrStudent> sturanks,
                                     List<MsrSubjectPoint> saveSubjectPoints,List<MsrSubjectPointSection> savePointSections,List<MsrSubjectPointRankgroup> savePointRankgroups){

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

     @Resource
     private MsrClassQtypeMapper msrClassQtypeMapper;
     @Resource
-    MsrSubjectQuestionRankgroupMapper msrSubjectQuestionRankgroupMapper;
+    private MsrSubjectQuestionRankgroupMapper msrSubjectQuestionRankgroupMapper;
     @Resource
-    MsrSubjectQuestionSectionMapper msrSubjectQuestionSectionMapper;
-
+    private MsrSubjectQuestionSectionMapper msrSubjectQuestionSectionMapper;
+    @Resource
+    private ReportGeneratePointService reportGeneratePointService;
 
     public void generateQuestion(Integer examid, Integer exammode) {
         // 查询所有学生试题
             handleQtype(subjectStuQuestions, subjectClassStudents, questions, subjectParams, examid, subjectid);
             //客观题、主观题
             handleObjSub(subjectStuQuestions, subjectClassStudents, questions, subjectStuPapers, examid, subjectid,subject.getPscore());
+            //知识点相关分析
+            reportGeneratePointService.generatePoint(subjectStuQuestions,questions,classStudents,stuPapers,examid,subjectid,subject.getMpid(),subject.getPscore());
         }
     }
 

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportsubject/PointParams.java

+package com.xhkjedu.smarking.vo.report.reportsubject;
+
+import lombok.Data;
+
+/**
+ * @Description：知识点传参数
+ * @Author: WN
+ * @Date: 2024/12/19 10:11:32
+ **/
+@Data
+public class PointParams {
+
+    private Integer examid;
+
+    private String subjectid;
+
+    private String pointid;
+
+    private String pointname;
+
+    private Double fullscore;//知识点满分
+
+    private Integer pointlevel;//1一级知识点（顶层），2二级知识点（上层），3三级知识点（自身）
+}