题型分析

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportstu/MsrStudentPoint.java

     private Double graderate;
     //知识点对应试题题号
     private String qns;
+    //知识点对应试题ID
+    private String mptqid;
 }

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

+package com.xhkjedu.smarking.service.report.generate;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.paper.MsPaperAnalyzeMapper;
+import com.xhkjedu.smarking.model.paper.MsPaperAnalyze;
+import com.xhkjedu.smarking.model.stupaper.MsPaperStudentQuestion;
+import com.xhkjedu.smarking.vo.paper.QuestionPointVo;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+/**
+ * @Description：生成知识点相关分析
+ * @Author: WN
+ * @Date: 2024/12/16 11:30:54
+ **/
+@Service
+public class ReportGeneratePointService {
+    @Resource
+    private MsPaperAnalyzeMapper msPaperAnalyzeMapper;
+
+    public void generatePoint(List<MsPaperStudentQuestion> stuQuestions,Integer mpid) {
+        //获取试卷分析
+        MsPaperAnalyze paperAnalyze = msPaperAnalyzeMapper.getObjByMpId(mpid);
+        if(paperAnalyze == null) return;
+
+        QuestionPointVo qpointvo = JSON.parseObject(paperAnalyze.getPointjson(), QuestionPointVo.class);
+    }
+}

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

 import com.xhkjedu.smarking.mapper.exam.MsClassStudentMapper;
 import com.xhkjedu.smarking.mapper.exam.MsSubjectMapper;
 import com.xhkjedu.smarking.mapper.paper.MsPaperQtypeQuestionMapper;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassQobjsubMapper;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassQtypeMapper;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassQuestionMapper;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassQuestionObjMapper;
 import com.xhkjedu.smarking.mapper.report.reportother.MsrReportparamMapper;
 import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectQuestionRankgroupMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectQuestionSectionMapper;
 import com.xhkjedu.smarking.mapper.stupaper.MsPaperStudentQuestionMapper;
 import com.xhkjedu.smarking.model.exam.MsClassStudent;
 import com.xhkjedu.smarking.model.paper.MsPaper;
     private MsrReportparamMapper msrReportparamMapper;
     @Resource
     private MsrStudentMapper msrStudentMapper;
+    @Resource
+    private MsrClassQuestionMapper msrClassQuestionMapper;
+    @Resource
+    private MsrClassQuestionObjMapper msrClassQuestionObjMapper;
+    @Resource
+    private MsrClassQobjsubMapper msrClassQobjsubMapper;
+    @Resource
+    private MsrClassQtypeMapper msrClassQtypeMapper;
+    @Resource
+    MsrSubjectQuestionRankgroupMapper msrSubjectQuestionRankgroupMapper;
+    @Resource
+    MsrSubjectQuestionSectionMapper msrSubjectQuestionSectionMapper;
+
 
     public void generateQuestion(Integer examid, Integer exammode) {
         // 查询所有学生试题
             handleQuestion(subjectStuQuestions, subjectClassStudents, questions, subjectParams, subjectStuPapers, examid, subjectid,subject.getPscore());
             //处理题型
             handleQtype(subjectStuQuestions, subjectClassStudents, questions, subjectParams, examid, subjectid);
+            //客观题、主观题
+            handleObjSub(subjectStuQuestions, subjectClassStudents, questions, subjectStuPapers, examid, subjectid,subject.getPscore());
         }
     }
 
         List<MsrClassQuestion> saveQuestions = new ArrayList<>();// 小题分析
         List<MsrClassQuestionObj> saveQuestionObjs = new ArrayList<>();// 小题-客观题选项分析
         List<MsrSubjectQuestionSection> saveSectionQuestions = new ArrayList<>();// 学科分段之间学生在该题的整体得分率
-        List<MsrSubjectQuestionRankgroup> saveRankGroupQuestions = new ArrayList<>();
+        List<MsrSubjectQuestionRankgroup> saveRankGroupQuestions = new ArrayList<>();//分组分数分布
 
         // 获取学生科目得分-科目默认分段学生
         List<MsrSubjectQuestionSection> subjectSectionQuestions = subjectSectionForQuestion(subjectStuPapers, pscore);
             schoolQ.setSchoolminscore(minScore);
             schoolQ.setSchoolavgscore(avgScore);
             schoolQ.setSchoolavgrate(avgScoreRate);
+            schoolQ.setMptqid(question.getMptqid());
+            schoolQ.setQn(question.getMptqn() + "." + question.getQn());
             // 全校班级试题情况
             MsrClassQuestion schoolQue = questionClass(stuQuestions, question, params, schoolQ);
             saveQuestions.add(schoolQue);
             }
 
             // 学科分段之间学生在该题的整体得分率
-            List<MsrSubjectQuestionSection> sectionQuestions = subjectSectionQuestion(stuQuestions, subjectSectionQuestions, question);
+            List<MsrSubjectQuestionSection> sectionQuestions = subjectSectionQuestion(stuQuestions, subjectSectionQuestions, 1,question.getQscore(),question.getMptqid());
             saveSectionQuestions.addAll(sectionQuestions);
             //试题分组分数分布、客观题选项分组
-            List<MsrSubjectQuestionRankgroup> rankGroupQuestions = questionScoreRankGroup(stuQuestions, subjectStuPapers,examid,subjectid,question);
+            List<MsrSubjectQuestionRankgroup> rankGroupQuestions = questionScoreRankGroup(stuQuestions, subjectStuPapers,examid,subjectid,question.getQtype(),question.getQscore(),question.getQtype());
             saveRankGroupQuestions.addAll(rankGroupQuestions);
 
             // 班级试题分析
                 }
             }
         }
+
+        if(!saveQuestions.isEmpty()) msrClassQuestionMapper.insertList(saveQuestions);
+        if(!saveQuestionObjs.isEmpty()) msrClassQuestionObjMapper.insertList(saveQuestionObjs);
+        if(!saveSectionQuestions.isEmpty()) msrSubjectQuestionSectionMapper.insertList(saveSectionQuestions);
+        if(!saveRankGroupQuestions.isEmpty()) msrSubjectQuestionRankgroupMapper.insertList(saveRankGroupQuestions);
+
     }
 
     // 单个试题分析-学校、班级分析
         List<MsPaperStudentQuestion> fullStuQuestions = stuQuestions.stream().filter(q -> q.getStuscore().equals(q.getQscore())).collect(Collectors.toList());
         String mfids = fullStuQuestions.stream().map(p -> p.getStudentid().toString()).collect(Collectors.joining(","));// 满分学生id
         classQ.setMfnum(fullStuQuestions.size());
-        classQ.setMfrate(MarkingUtil.div(classQ.getMfnum(), stunum));////正确率、满分人数占比
+        classQ.setMfrate(MarkingUtil.calculateRate(classQ.getMfnum(), stunum));////正确率、满分人数占比
         classQ.setMfids(mfids);
         // 获取零分学生
         List<MsPaperStudentQuestion> lfStuQuestions = stuQuestions.stream().filter(q -> q.getStuscore() == 0).collect(Collectors.toList());
         String lfids = lfStuQuestions.stream().map(p -> p.getStudentid().toString()).collect(Collectors.joining(","));// 零分学生id
         classQ.setLfnum(lfStuQuestions.size());
-        classQ.setLfrate(MarkingUtil.div(lfStuQuestions.size(), stunum));////零分人数占比
+        classQ.setLfrate(MarkingUtil.calculateRate(lfStuQuestions.size(), stunum));////零分人数占比
         classQ.setLfids(lfids);
         return classQ;
     }
         return qobjList;
     }
     // 单个试题分析-小题分组分布、客观题选项分组分布
-    private List<MsrSubjectQuestionRankgroup> questionScoreRankGroup(List<MsPaperStudentQuestion> stuQuestions,List<MsrStudent> stuPapers,Integer examid,String subjectid,MsPaperQtypeQuestion question){
+    private List<MsrSubjectQuestionRankgroup> questionScoreRankGroup(List<MsPaperStudentQuestion> stuQuestions,List<MsrStudent> stuPapers,Integer examid,String subjectid,Integer qtype,Double fullScore,Integer mptqid){
         //获取学生排名最大名次的树
         Integer totalRank = stuPapers.stream().mapToInt(MsrStudent::getSchoolrank).max().orElse(0);
         //获取排名分组,默认分为7组
         List<RankGroupVo> rankGroups = MarkingUtil.rankGroup(totalRank,7);
         //获取试题分段,1分1段
-        List<SectionScoreVo> sectionScores = MarkingUtil.fdScoreForOne(question.getQscore());
+        List<SectionScoreVo> sectionScores = MarkingUtil.fdScoreForOne(fullScore);
 
         //获取所有客观题选项内容
         List<String> options = new ArrayList<>();
-        if(question.getQtype() == 1){
+        if(qtype == 1){
             options = stuQuestions.stream().map(MsPaperStudentQuestion::getStuanswer).distinct().collect(Collectors.toList());
         }
 
             MsrSubjectQuestionRankgroup sqr = new MsrSubjectQuestionRankgroup();
             sqr.setExamid(examid);
             sqr.setSubjectid(subjectid);
-            sqr.setQntype(1);
-            sqr.setMptqid(question.getMptqid());
+            if(qtype == 1){
+                sqr.setQntype(1);//类型1小题2客观题3主观题
+                sqr.setRgtype(1);//类型1客观题选项 2客/主分值
+            }else{
+                //类型1小题2客观题3主观题
+                if(qtype == 2){
+                    sqr.setQntype(1);
+                }else if(qtype == 11){
+                    sqr.setQntype(2);
+                }else{
+                    sqr.setQntype(3);
+                }
+
+                sqr.setRgtype(2);//类型1客观题选项 2客/主分值
+            }
+            sqr.setMptqid(mptqid);
             sqr.setRgroup(rankGroup.getGroupname());
-            sqr.setRgtype(2);
+
             List<Integer> groupStuids;
             List<MsPaperStudentQuestion> groupStuQuestions = null;
             if(!groupStus.isEmpty()){
                 double avgScore = MarkingUtil.div(sumScore, groupStuQuestions.size());
                 sqr.setStunum(groupStuQuestions.size());
                 sqr.setStuids(groupStuQuestions.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
-                sqr.setScorerate(MarkingUtil.calculateRate(sumScore, groupStuQuestions.size() * question.getQscore()));
-                sqr.setAvgrate(MarkingUtil.calculateRate(avgScore, question.getQscore()));
+                sqr.setScorerate(MarkingUtil.calculateRate(sumScore, groupStuQuestions.size() * fullScore));
+                sqr.setAvgrate(MarkingUtil.calculateRate(avgScore, fullScore));
             } else {
                 groupStuids = null;
                 sqr.setStunum(0);
                 sqrg.setExamid(examid);
                 sqrg.setSubjectid(subjectid);
                 sqrg.setQntype(1);
-                sqrg.setMptqid(question.getMptqid());
+                sqrg.setMptqid(mptqid);
                 sqrg.setRgroup(rankGroup.getGroupname());
                 sqrg.setRgtype(2);
                 sqrg.setRgvalue(sectionScore.getSectionname());
                 if(groupStuids != null && !groupStuids.isEmpty()){
                     //名次分组下有学生，进行学生分数段计算
                     List<MsPaperStudentQuestion> sectionStuQuestions;
-                    if(sectionScore.getMinvalue() == question.getQscore()){
+                    if(sectionScore.getMinvalue() == fullScore){
                         //最小值为满分时分段形式为[qscore,qscore)
                         sectionStuQuestions = groupStuQuestions.stream().filter(q -> q.getStuscore() >= sectionScore.getMinvalue()).collect(Collectors.toList());
                     }else{
                     double sectionStuAvgScore = MarkingUtil.div(sectionStuSumScore, sectionStuQuestions.size());
                     sqrg.setStunum(sectionStuQuestions.size());
                     sqrg.setStuids(sectionStuQuestions.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
-                    sqrg.setScorerate(MarkingUtil.calculateRate(sectionStuSumScore, sectionStuQuestions.size() * question.getQscore()));
-                    sqrg.setAvgrate(MarkingUtil.calculateRate(sectionStuAvgScore, question.getQscore()));
+                    sqrg.setScorerate(MarkingUtil.calculateRate(sectionStuSumScore, sectionStuQuestions.size() * fullScore));
+                    sqrg.setAvgrate(MarkingUtil.calculateRate(sectionStuAvgScore, fullScore));
                 }else{
                     sqrg.setStunum(0);
                     sqrg.setScorerate(0.0);
             }
 
             //客观题选项
-            if(question.getQtype() == 1){
+            if(qtype == 1){
                 if(options.isEmpty()){
                     options = new ArrayList<>();
                     options.add("");
 
                         optionObj.setStunum(optionStuQuestions.size());
                         optionObj.setStuids(optionStuQuestions.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
-                        optionObj.setScorerate(MarkingUtil.calculateRate(optionStuSumScore, optionStuQuestions.size() * question.getQscore()));
-                        optionObj.setAvgrate(MarkingUtil.calculateRate(optionStuAvgScore, question.getQscore()));
+                        optionObj.setScorerate(MarkingUtil.calculateRate(optionStuSumScore, optionStuQuestions.size() * fullScore));
+                        optionObj.setAvgrate(MarkingUtil.calculateRate(optionStuAvgScore, fullScore));
                     }else{
                         optionObj.setStunum(0);
                         optionObj.setScorerate(0.0);
 
     // 单个试题分析-科目分段区间得分率
     private List<MsrSubjectQuestionSection> subjectSectionQuestion(List<MsPaperStudentQuestion> stuQuestions, List<MsrSubjectQuestionSection> sections,
-                                                                         MsPaperQtypeQuestion question) {
+                            Integer qtype,Double fullScore,Integer mptqid) {
         List<MsrSubjectQuestionSection> rtnList = new ArrayList<>();
         for (MsrSubjectQuestionSection section : sections) {
             String[] userids = section.getFdids().split(",");
             // 获取平均分
             double avgScore = MarkingUtil.div(sumScore, stuNum);
             // 获取平均得分率
-            double avgScoreRate = MarkingUtil.calculateRate(avgScore, question.getQscore());
+            double avgScoreRate = MarkingUtil.calculateRate(avgScore, fullScore);
             section.setAvgscore(avgScore);
             section.setAvgrate(avgScoreRate);
-            section.setQntype(1);
-            section.setMptqid(question.getMptqid());
+            if(qtype == 1){
+                section.setQntype(qtype);//类型1小题2客观题3主观题
+            }else{
+                section.setQntype(qtype+1);
+            }
+            section.setMptqid(mptqid);
             rtnList.add(section);
         }
         return rtnList;
 
     // 题型分析
     private void handleQtype(List<MsPaperStudentQuestion> subjectStuQuestions,List<MsClassStudent> subjectClassStudents, List<MsPaperQtypeQuestion> questions,
-                             List<MsrReportparam> params,Integer examid, String subjectid) {
+                            List<MsrReportparam> params,Integer examid, String subjectid) {
         List<MsrClassQtype> saveQtypes = new ArrayList<>();//班级题型分析
         // 处理大题
         Map<Integer, List<MsPaperQtypeQuestion>> qtypeMap = questions.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestion::getMptid));
                 saveQtypes.add(qtypeClass);
             }
         }
+        if(!saveQtypes.isEmpty()) msrClassQtypeMapper.insertList(saveQtypes);
     }
     // 题型分析-学校、班级分析
     private MsrClassQtype qtypeClass(List<MsPaperStudentQuestion> stuQuestions, List<MsrReportparam> params,MsrClassQtype schoolQtype){
         classQtype.setQfd(MarkingUtil.qfd(stuScores));
         classQtype.setQfdms(questionNdAndQfd(params, 2, schoolQtype.getQfd())[0]);
         classQtype.setMfnum(mfnum);
-        classQtype.setMfrate(MarkingUtil.div(mfnum, stuNum));
+        classQtype.setMfrate(MarkingUtil.calculateRate(mfnum, stuNum));
         if(mfnum > 0){
             schoolQtype.setMfids(mfids.substring(0,mfids.length()-1));
         }
         classQtype.setMfids(mfids.toString());
         classQtype.setLfnum(lfnum);
-        classQtype.setLfrate(MarkingUtil.div(lfnum, stuNum));
+        classQtype.setLfrate(MarkingUtil.calculateRate(lfnum, stuNum));
         if(lfnum > 0){
             classQtype.setMfids(lfids.substring(0,lfids.length()-1));
         }
 
     //客观题/主观题分析
     private void handleObjSub(List<MsPaperStudentQuestion> subjectStuQuestions,List<MsClassStudent> subjectClassStudents, List<MsPaperQtypeQuestion> questions,
-                              List<MsrReportparam> params,Integer examid, String subjectid){
+                                List<MsrStudent> subjectStuPapers,Integer examid, String subjectid,Double pscore){
 
         List<MsrClassQobjsub> saveObjSubs = new ArrayList<>();//客观题/主观题分析
+        List<MsrSubjectQuestionSection> saveSectionQuestions = new ArrayList<>();// 学科分段之间学生在该题的整体得分率
+        List<MsrSubjectQuestionRankgroup> saveRankGroupQuestions = new ArrayList<>();//分组分数分布
+
+        // 获取学生科目得分-科目默认分段学生
+        List<MsrSubjectQuestionSection> subjectSectionQuestions = subjectSectionForQuestion(subjectStuPapers, pscore);
 
         //根据试题类型分组
         Map<Integer,List<MsPaperQtypeQuestion>> objSubMap = questions.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestion::getQtype));
             MsrClassQobjsub objSubSchool = qobjsubClass(stuQuestions, schoolObjSub);
             saveObjSubs.add(objSubSchool);
 
+            // 学科分段之间学生在该题的整体得分率,qntype=1小题2客观题3主观题
+            List<MsrSubjectQuestionSection> sectionQuestions = subjectSectionQuestion(stuQuestions, subjectSectionQuestions,entry.getKey(), fullScore,null);
+            saveSectionQuestions.addAll(sectionQuestions);
+
+
+            Integer qobjsubtype;//为了区分表中存放值
+            if(entry.getKey() == 1){
+                qobjsubtype = 11;
+            }else{
+                qobjsubtype = 12;
+            }
+            //试题分组分数分布、客观题选项分组、客观题主观题分组分数分布
+            List<MsrSubjectQuestionRankgroup> rankGroupQuestions = questionScoreRankGroup(stuQuestions, subjectStuPapers,examid,subjectid, qobjsubtype, fullScore,null);
+            saveRankGroupQuestions.addAll(rankGroupQuestions);
+
             List<Integer> classIds = subjectClassStudents.stream().map(MsClassStudent::getClassid).distinct().collect(Collectors.toList());
             for (Integer classid : classIds) {
                 schoolObjSub.setClassid(classid);
                 saveObjSubs.add(objSubClass);
             }
         }
+
+        if(!saveObjSubs.isEmpty()) msrClassQobjsubMapper.insertList(saveObjSubs);
+        if(!saveSectionQuestions.isEmpty()) msrSubjectQuestionSectionMapper.insertList(saveSectionQuestions);
+        if(!saveRankGroupQuestions.isEmpty()) msrSubjectQuestionRankgroupMapper.insertList(saveRankGroupQuestions);
     }
     //客观题/主观题分析--学校、班级分析
     private MsrClassQobjsub qobjsubClass(List<MsPaperStudentQuestion> stuQuestions, MsrClassQobjsub schoolObjsub){
         objSub.setCyxs(MarkingUtil.div(objSub.getBzc(), avgScore));
         objSub.setJbzs(MarkingUtil.jbzs(stuScores, stuScoreRate));
         objSub.setMfnum(mfnum);
-        objSub.setMfrate(MarkingUtil.div(mfnum, stuNum));
+        objSub.setMfrate(MarkingUtil.calculateRate(mfnum, stuNum));
         if(mfnum > 0){
             objSub.setMfids(mfids.substring(0,mfids.length()-1));
         }
         objSub.setLfnum(lfnum);
-        objSub.setLfrate(MarkingUtil.div(lfnum, stuNum));
+        objSub.setLfrate(MarkingUtil.calculateRate(lfnum, stuNum));
         if(lfnum > 0){
             objSub.setLfids(lfids.substring(0,lfids.length()-1));
         }