班级、学生题型分析

sexam/src/main/java/com/xhkjedu/sexam/model/reportstu/ERStudentQtype.java

     private Integer examid;
 
     //科目id
-    private Integer subjectid;
+    private String subjectid;
 
     //学生id
     private Integer studentid;
 
+    //试卷id
+    private Integer epid;
+
     //班级id
     private Integer classid;
 

sexam/src/main/java/com/xhkjedu/sexam/service/paper/EPaperQtypeService.java

         List<EPaperQtypeQuestion> uplist = new ArrayList<>();//改试卷中客观题选项数量
         List<QuestionOrderVo> pointqlist = new ArrayList<>();//用于存放知识点，以及知识点下得分
         List<EPaperQtypeQuestionVo> mquestions = new ArrayList<>();//存放单题和母题
+        List<QuestionOrderVo> complexitylist = new ArrayList<>();//试题难易度存放试题
 
-        //处理题型1单选题2多选题3主观题4判断对错5判断√×6判断TF7完形填空8阅读理解10任务型阅读11综合题12听力
-        List<Map> typelist = new ArrayList<>();//题型分析
         //处理出试卷中所有试题、知识点
+        List<Map> typelist = new ArrayList<>();//题型分析
         for(EPaperQtypeVo qt : qtypelist){
             List<Integer> qorderlist = new ArrayList<>();
             List<QuestionOrderVo> qtypeqlist = new ArrayList<>();
                     //处理试题知识点占分
                     setPaperQuestionPointScore(pointqlist,qpoints,q,null,null);
                     setPaperQuestionQtypeScore(qtypeqlist,q,null,null);//处理试题题型
+                    setPaperQuestionComplexityScore(complexitylist,q,null,null);//处理试题难易度
                 }
                 if(q.getQlevel() == 3){
                     hasmt ++;
                         }else{
                             mq.setMctype(112);
                         }
-
-                        mquestions.add(mq);
                         mq.setQlevel(qobj.getMqlevel());
+                        mq.setSonques(sonques);
                         //获取所有子题的试题题号
                         List<String> qns = sonques.stream().map(EPaperQtypeQuestionVo::getQn).collect(Collectors.toList());
                         String[] qnstr = qns.stream().toArray(String[]::new);
                         //获取知识点
                         List<Map> qpoints = sonques.get(0).getPoints();
                         mq.setPoints(qpoints);
+                        mquestions.add(mq);
                         setPaperQuestionPointScore(pointqlist,qpoints,mq,qnstr,eptqidstr);
                         setPaperQuestionQtypeScore(qtypeqlist,mq,qnstr,eptqidstr);//处理试题题型
+                        setPaperQuestionComplexityScore(complexitylist,mq,qnstr,eptqidstr);//处理试题难易度
                     }
                 }
             }
         ztmap.put("ranglist",ranglist);
 
         //难易度
-        Map<Integer,List<EPaperQtypeQuestionVo>> complxmap =  mquestions.stream().collect(Collectors.groupingBy(EPaperQtypeQuestionVo:: getComplexity, Collectors.toList()));
         List<Map> clist = new ArrayList<>();
-        for(Map.Entry<Integer, List<EPaperQtypeQuestionVo>> entry : complxmap.entrySet()){
-            Map cmap = new HashMap();
-            cmap.put("level",entry.getKey());
-            List<EPaperQtypeQuestionVo> aq = entry.getValue();
-            double cscore = aq.stream().collect(Collectors.summingDouble(EPaperQtypeQuestionVo:: getScore));
-            double scorerate = N_Utils.getDoubleDivideAndMulitiply(cscore, ePaper.getPscore());
-            cmap.put("score",cscore);
-            cmap.put("srate",scorerate);
-            clist.add(cmap);
+        if(N_Utils.isListNotEmpty(complexitylist)){
+            Map<String,List<QuestionOrderVo>> complxmap =  complexitylist.stream().collect(Collectors.groupingBy(QuestionOrderVo:: getId, Collectors.toList()));
+            for(Map.Entry<String, List<QuestionOrderVo>> entry : complxmap.entrySet()){
+                List<QuestionOrderVo> pgblist = entry.getValue();
+                Double score = pgblist.stream().mapToDouble(s -> s.getScore()).sum();
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score,ePaper.getPscore());
+                Map prate = new HashMap();
+                prate.put("level",Integer.parseInt(entry.getKey()));
+                prate.put("score",score);
+                prate.put("srate",srate);
+                prate.put("ques",pgblist);
+                clist.add(prate);
+            }
         }
 
         //知识点分析
 
         qtypelist.add(qtype);
     }
+
+    //设置试题难易度
+    private void setPaperQuestionComplexityScore(List<QuestionOrderVo> complexityList,EPaperQtypeQuestionVo dq,String[] qnstr,Integer[] eptqidstr){
+        QuestionOrderVo qtype = new QuestionOrderVo();
+        qtype.setId(dq.getComplexity().toString());//存放试题难易度
+        qtype.setOrder(dq.getQorder());
+        qtype.setScore(dq.getScore());
+        qtype.setQlevel(dq.getQlevel());
+        if(qnstr == null){
+            qtype.setQns(new String[]{dq.getQn()});
+        }else{
+            qtype.setQns(qnstr);
+        }
+        if(eptqidstr == null){
+            qtype.setEptqids(new Integer[]{dq.getEptqid()});
+        }else{
+            qtype.setEptqids(eptqidstr);
+        }
+
+        complexityList.add(qtype);
+    }
     //保存试卷分析--附件
     private void savePaperAnalyzeForFj(EPaper ePaper,List<EPaperQtype> fjtypelist,List<EPaperQtypeQuestion> queslist){
         //保存之前先清除之前的试卷分析
             double storerate = N_Utils.getDoubleDivideAndMulitiply(tscore, ePaper.getPscore());
             //获取小题题号
 
-            List<String> allqns = new ArrayList<>();
             List<Integer> orderlist = new ArrayList<>();
             List<Integer> eptqidlist = new ArrayList<>();
             List<String> qnlist = new ArrayList<>();
             tmap.put("num",num);
             tmap.put("score",tscore);
             tmap.put("srate",storerate);
-            tmap.put("qns",anmap);
+            tmap.put("ques",anmap);
             qtlist.add(tmap);
         }
 
                 //试题类型1单题2母题3子题
                 if(q.getQlevel() == 3){
                    if(!q.getQuestionpid().equals(qpid)){
-                       sonqlist = qlist.stream().filter(o -> o.getQuestionpid().equals(q.getQuestionpid())).collect(Collectors.toList());
+                       sonqlist = qlist.stream().filter(o -> q.getQlevel()==3 && q.getQuestionpid().equals(o.getQuestionpid())).collect(Collectors.toList());
                        EPaperQtypeQuestionVo mq = new EPaperQtypeQuestionVo();
                        mq.setQuestionid(q.getQuestionpid());
                        mq.setCtype(q.getMctype());
                        mq.setQanswer(q.getMqanswer());
                        mq.setQorder(q.getQorder());
                        mq.setQlevel(q.getMqlevel());
-                       mq.setMhashear(q.getMhashear());
-                       mq.setMhearfile(q.getMhearfile());
-                       List<Map> allpoint = new ArrayList<>();
-                       for(EPaperQtypeQuestionVo sq : sonqlist){
-                           List<Map> sqpoints = sq.getPoints();
-                           for(Map p : sqpoints){
-                               if(!isExistEPaperPoints(allpoint,p)){
-                                   allpoint.add(p);
-                               }
-                           }
-                       }
+                       mq.setHashear(q.getMhashear());
+                       mq.setHearfile(q.getMhearfile());
                        Double mscore = sonqlist.stream().collect(Collectors.summingDouble(EPaperQtypeQuestionVo:: getScore));
                        mq.setScore(mscore);
                        mq.setSonques(sonqlist);
-                       mq.setPoints(allpoint);
+                       mq.setPoints(sonqlist.get(0).getPoints());
                        rtnqlist.add(mq);
                    }
                     qpid = q.getQuestionpid();
                 }else{
-                    EPaperQtypeQuestionVo mq = new EPaperQtypeQuestionVo();
+                    /*EPaperQtypeQuestionVo mq = new EPaperQtypeQuestionVo();
                     BeanUtils.copyProperties(q,mq);
-                    mq.setCtype(mq.getCtype());
-                    rtnqlist.add(mq);
+                    mq.setCtype(mq.getCtype());*/
+                    rtnqlist.add(q);
                 }
             }
             qt.setQuestions(rtnqlist);

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

 import com.xhkjedu.sexam.utils.ExamUtil;
 import com.xhkjedu.sexam.vo.paper.EPaperQtypeQuestionVo;
 import com.xhkjedu.sexam.vo.paper.EPaperQtypeVo;
+import com.xhkjedu.sexam.vo.paper.QuestionOrderVo;
 import com.xhkjedu.sexam.vo.report.ERClassScoreVo;
 import com.xhkjedu.sexam.vo.report.ERPaperVo;
 import com.xhkjedu.utils.N_Utils;
 
     //题型、试题、知识点
     private void setClassQuestion(Integer examid,List<Map> subjects,List<Map> classes){
-        //考试所有学生提交试卷情况
+        //考试所有学生提交试卷作答情况
         List<EPaperStudentQuestion> stulist = ePaperStudentQuestionMapper.listExamStudentsAnswer(examid);
 
-        List<ERclassQtype> rtypelist = new ArrayList<>();
-        List<ERclassQuestion> rqlist = new ArrayList<>();
-        List<ERclassQuestionPoint> rpointlist = new ArrayList<>();
-        List<ERStudentQtype> stuqtypes = new ArrayList<>();
-        List<ERstudentPoint> stupoints = new ArrayList<>();
+        List<ERclassQtype> rtypelist = new ArrayList<>();//班级题型
+        List<ERclassQuestion> rqueslist = new ArrayList<>();//班级试题
+        List<ERclassQuestionPoint> rpointlist = new ArrayList<>();//班级知识点
+        List<ERStudentQtype> stutypelist = new ArrayList<>();//学生题型
+        List<ERstudentPoint> stupointlist = new ArrayList<>();//学生知识点
 
         for(Map map : subjects){
             String subjectid = map.get("subjectid").toString();
+            String subjectname = map.get("subjectname").toString();
             Integer epid = Integer.parseInt(map.get("epid").toString());//获取试卷id
             Integer ptype = Integer.parseInt(map.get("ptype").toString());//试卷类型1题库2附件
             Double pscore = Double.parseDouble(map.get("pscore").toString());
-            List<EPaperQtypeVo> fjtypelist = new ArrayList<>();
-            if(ptype == 1){
-                fjtypelist = ePaperQtypeMapper.listPaperQtypeQuestions(epid);//试卷题型试题信息（题库）
-                setEPaperQtypeForQues(fjtypelist);
-            }else{
-                fjtypelist = ePaperQtypeMapper.listPaperQtypeQuesitonsForFj(epid);//试卷题型试题信息（附件）
-            }
 
-            //获取试卷只是分析
-            Map epa = ePaperAnalyzeMapper.getPaperAnalzyeByEpid(epid);
-            String qtypejson = epa.get("qnumjson").toString();//原试卷题型分析
-            List<Map> qtypelist = JSON.parseArray(qtypejson,Map.class);
-            for(int k = 0;k<qtypelist.size();k++){
-                
-            }
+            //获取试卷本身的分析
+            Map panalyze = ePaperAnalyzeMapper.getPaperAnalzyeByEpid(epid);
+            //获取指定试卷学生作答情况
+            List<EPaperStudentQuestion> paperstulist = stulist.stream().filter(s -> s.getEpid().equals(epid)).collect(Collectors.toList());
 
-            //遍及试卷处理题型下各班级得分情况
-            for(EPaperQtypeVo t : fjtypelist){
-                Double eptscore = t.getEptscore();
-                Double tgscore = 0.0;//题型下年级得分
-                int stunum = 0;
-                Map<Integer, ERClassScoreVo> tcmap = new HashMap<>();//题型下班级得分
-                String qnstr = "";
-                List<EPaperQtypeQuestionVo> questionVos = t.getQuestions();
-                for(int i=0;i<questionVos.size();i++){
-                    EPaperQtypeQuestionVo q = questionVos.get(i);
-                    if (i ==0){
-                        qnstr = q.getQn();
-                    }else{
-                        qnstr = qnstr + "," + q.getQn();
-                    }
+            if(ptype == 1){
+                //处理题型下试题
 
-                    //获取指定试题试题得分
-                    List<EPaperStudentQuestion> qstu = stulist.stream().filter(o -> o.getEpid().equals(t.getEpid())
-                             && o.getEptqid().equals(q.getEptqid())).collect(Collectors.toList());
-                    if(i == 0){
-                        stunum = qstu.size();
-                    }
-                    EPaperStudentQuestion maxscoreStu = qstu.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();//最高分
-                    Double qgscore = qstu.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                    Double qgavgscore = N_Utils.getDoubleDivideAndMulitiply(qgscore,qstu.size());//年级平均分
-                    Double qgsrate = N_Utils.getDoubleDivideAndMulitiply(qgscore,q.getScore() * qstu.size());
-                    tgscore = ExamUtil.add(tgscore,qgscore);
+                //处理知识点
 
-                    for(Map classm : classes){
-                        Integer classid = Integer.parseInt(classm.get("classid").toString());
-                        List<EPaperStudentQuestion> classStu = qstu.stream().filter(o -> o.getClassid().equals(classid)).collect(Collectors.toList());
-                        EPaperStudentQuestion maxclassstu = classStu.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();//最高分
-                        Double qallstu = classStu.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
-                        Double qcavgscore = N_Utils.getDoubleDivideAndMulitiply(qallstu,classStu.size());//年级平均分
-                        Double qcsrate = N_Utils.getDoubleDivideAndMulitiply(qallstu,q.getScore() * classStu.size());
-
-                        ERclassQuestion ercq = new ERclassQuestion();
-                        ercq.setExamid(examid);
-                        ercq.setClassid(classid);
-                        ercq.setSubjectid(subjectid);
-                        ercq.setEptqid(q.getEptqid());
-                        ercq.setQn(q.getQn());
-                        ercq.setQorder(q.getQorder());
-                        if(ptype == 1){
-                            ercq.setComplexity(q.getComplexity());
-                        }
-                        ercq.setClassmaxscore(maxclassstu.getStuscore());
-                        ercq.setClassavgscore(qcavgscore);
-                        ercq.setClasssrate(qcsrate);
-                        ercq.setGrademaxscore(maxscoreStu.getStuscore());
-                        ercq.setGradeavgscore(qgavgscore);
-                        ercq.setGradesrate(qgsrate);
-                        //处理单选题选项情况
-                        Map stuansmap = setPaperQuestionsForStu(q,classStu);
-                        ercq.setAnswerjson(stuansmap.get("answerlist").toString());
-                        ercq.setGoodstujson(stuansmap.get("goodlist").toString());
-                        ercq.setBadstujson(stuansmap.get("badlist").toString());
-                        rqlist.add(ercq);//单个试题统计
-
-                        if(tcmap.containsKey(classid)){
-                            ERClassScoreVo erClassScoreVo = tcmap.get(classid);
-                            if(i ==0){
-                                erClassScoreVo.setStunum(classStu.size());
-                                erClassScoreVo.setTcscore(0.0);
+                //处理难易度
+
+            }else{
+                //附件试卷,主要处理题型及题型下试题
+                String qtypejson = panalyze.get("qnumjson").toString();//原试卷题型分析
+                List<Map> qtypelist = JSON.parseArray(qtypejson,Map.class);
+                for(int k = 0;k<qtypelist.size();k++){
+                    Map qtypemap = qtypelist.get(k);
+                    String qtypename = qtypemap.get("qtypename").toString();
+                    Double score = Double.parseDouble(qtypemap.get("score").toString());//题型下试题总分值
+                    Double srate = Double.parseDouble(qtypemap.get("srate").toString());//题型下试题分值占比
+                    Integer num = Integer.parseInt(qtypemap.get("num").toString());//题型下试题数量
+                    Map ques = (Map) qtypemap.get("ques");//试题相关对象
+                    List<Integer> eptqids = (List<Integer>) ques.get("eptqids");//试卷中题型下试题id
+                    List<String> qns = (List<String>) ques.get("qns");//试卷中试题题号
+                    List<Integer> orders = (List<Integer>) ques.get("orders");//试卷中试题题号
+
+                    Double tgstuscore = 0.0;
+                    Double tgscore = 0.0;
+                    int gstunum = 0;
+                    Map<Integer,ERClassScoreVo> tclassmap = new HashMap<>();
+                    Map<Integer,ERStudentQtype> tstumap = new HashMap<>();
+
+                    for(int q = 0;q<eptqids.size();q++){
+                        Integer eptqid = eptqids.get(q);
+                        //获取改题所有学生作答情况
+                        List<EPaperStudentQuestion> qgstulist = paperstulist.stream().filter(s -> s.getEptqid().equals(eptqid)).collect(Collectors.toList());
+                        gstunum = qgstulist.size();
+                        EPaperStudentQuestion qgmaxstu = qgstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
+                        Double qgscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                        Double qgstuscore = qgstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                        Double qgavgscore = N_Utils.getDoubleDivideAndMulitiply(qgstuscore,gstunum);//年级平均分
+                        Double qgsrate = N_Utils.getDoubleDivideAndMulitiply(qgstuscore,qgscore);
+                        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();//班级下试题作答学生数量
+                            EPaperStudentQuestion qcmaxstu = qcstulist.stream().max(Comparator.comparing(EPaperStudentQuestion::getStuscore)).get();
+                            Double qcscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getQscore).sum();
+                            Double qcstuscore = qcstulist.stream().mapToDouble(EPaperStudentQuestion::getStuscore).sum();
+                            Double qcavgscore = N_Utils.getDoubleDivideAndMulitiply(qcstuscore,cstunum);
+                            Double qcsrate = N_Utils.getDoubleDivideAndMulitiply(qcstuscore,qcscore);
+
+                            //班级单题情况
+                            ERclassQuestion ercq = new ERclassQuestion();
+                            ercq.setExamid(examid);
+                            ercq.setClassid(classid);
+                            ercq.setSubjectid(subjectid);
+                            ercq.setEptqid(eptqid);
+                            ercq.setQn(qns.get(q));
+                            ercq.setQorder(orders.get(q));
+                            ercq.setClassmaxscore(qcmaxstu.getStuscore());
+                            ercq.setClassavgscore(qcavgscore);
+                            ercq.setClasssrate(qcsrate);
+                            ercq.setGrademaxscore(qgmaxstu.getStuscore());
+                            ercq.setGradeavgscore(qgavgscore);
+                            ercq.setGradesrate(qgsrate);
+                            //处理单选题选项情况
+                            Map stuansmap = setPaperQuestionsForStuAnswer(qcstulist);
+                            ercq.setAnswerjson(stuansmap.get("answerlist").toString());
+                            ercq.setGoodstujson(stuansmap.get("goodlist").toString());
+                            ercq.setBadstujson(stuansmap.get("badlist").toString());
+                            rqueslist.add(ercq);//单个试题统计
+
+                            if(tclassmap.containsKey(classid)){
+                                ERClassScoreVo erClassScoreVo = tclassmap.get(classid);
+                                erClassScoreVo.setStuscore(ExamUtil.add(erClassScoreVo.getStuscore(), qcstuscore));
+                                erClassScoreVo.setCscore(ExamUtil.add(erClassScoreVo.getStuscore(), qcscore));
+                            }else{
+                                ERClassScoreVo erClassScoreVo = new ERClassScoreVo();
+                                erClassScoreVo.setStunum(cstunum);
+                                erClassScoreVo.setStuscore(erClassScoreVo.getStuscore());
+                                erClassScoreVo.setCscore(erClassScoreVo.getStuscore());
+                                tclassmap.put(classid,erClassScoreVo);
                             }
-                            erClassScoreVo.setTcscore(ExamUtil.add(erClassScoreVo.getTcscore(), qallstu));
-
-                        }else{
-                            ERClassScoreVo erClassScoreVo = new ERClassScoreVo();
-                            erClassScoreVo.setStunum(classStu.size());
-                            erClassScoreVo.setTcscore(0.0);
-                            erClassScoreVo.setTcscore(ExamUtil.add(erClassScoreVo.getTcscore(), qallstu));
-                            tcmap.put(classid,erClassScoreVo);
+                            setEPaperQuestionQtypesStu(qcstulist,tstumap);//设置学生题型下得分
                         }
                     }
-                }
 
-                Double tgavescore = N_Utils.getDoubleDivideAndMulitiply(tgscore,stunum);//题型下年级平均分
-                Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgscore,eptscore * stunum);//年级得分率
-
-                for(Map.Entry<Integer,ERClassScoreVo> entry : tcmap.entrySet()){
-                    ERClassScoreVo erClassScoreVo = entry.getValue();
-                    ERclassQtype eRclassQtype = new ERclassQtype();
-                    eRclassQtype.setExamid(examid);
-                    eRclassQtype.setSubjectid(subjectid);
-                    eRclassQtype.setEpid(epid);
-                    eRclassQtype.setClassid(entry.getKey());
-                    eRclassQtype.setQtypename(t.getEptname());
-                    eRclassQtype.setScore(eptscore);
-                    eRclassQtype.setNum(t.getEptnum());
-                    eRclassQtype.setSrate(N_Utils.getDoubleDivideAndMulitiply(eptscore,pscore));
-                    eRclassQtype.setGradeavgscore(tgavescore);
-                    eRclassQtype.setGradesrate(tgsrate);
-                    eRclassQtype.setClassavgscore(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getTcscore(),erClassScoreVo.getStunum()));
-                    eRclassQtype.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getTcscore(),eptscore * erClassScoreVo.getStunum() ));
-                    eRclassQtype.setQns(qnstr);
-
-                    rtypelist.add(eRclassQtype);
+                    Double tgavgscore = N_Utils.getDoubleDivideAndMulitiply(tgstuscore,gstunum);//题型下年级平均分
+                    Double tgsrate = N_Utils.getDoubleDivideAndMulitiply(tgstuscore,tgscore);//年级得分率
+
+                    //题型--班级得分
+                    for(Map.Entry<Integer,ERClassScoreVo> entry : tclassmap.entrySet()){
+                        ERClassScoreVo erClassScoreVo = entry.getValue();
+                        ERclassQtype eRclassQtype = new ERclassQtype();
+                        eRclassQtype.setExamid(examid);
+                        eRclassQtype.setSubjectid(subjectid);
+                        eRclassQtype.setEpid(epid);
+                        eRclassQtype.setClassid(entry.getKey());
+                        eRclassQtype.setQtypename(qtypename);
+                        eRclassQtype.setScore(score);
+                        eRclassQtype.setNum(num);
+                        eRclassQtype.setSrate(srate);
+                        eRclassQtype.setGradeavgscore(tgavgscore);
+                        eRclassQtype.setGradesrate(tgsrate);
+                        eRclassQtype.setClassavgscore(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getStuscore(),erClassScoreVo.getStunum()));
+                        eRclassQtype.setClasssrate(N_Utils.getDoubleDivideAndMulitiply(erClassScoreVo.getStuscore(),erClassScoreVo.getCscore()));
+                        eRclassQtype.setQns(qns.stream().map(String::valueOf).collect(Collectors.joining(",")));
+                        rtypelist.add(eRclassQtype);
+                    }
+
+                    //题型--学生得分
+                    for(Map.Entry<Integer,ERStudentQtype> entry : tstumap.entrySet()){
+                        ERStudentQtype erStudentQtype = entry.getValue();
+                        erStudentQtype.setExamid(examid);
+                        erStudentQtype.setSubjectid(subjectid);
+                        erStudentQtype.setEpid(epid);
+                        erStudentQtype.setQtypename(qtypename);
+                        erStudentQtype.setStusrate(N_Utils.getDoubleDivideAndMulitiply(erStudentQtype.getStuscore(),score));
+                        stutypelist.add(erStudentQtype);
+                    }
                 }
             }
 
-
             //仅有题库试卷有知识点
             if(ptype == 1){
-                String pointjson = epa.get("pointjson").toString();
+                String pointjson = panalyze.get("pointjson").toString();
                 List<Map> pointlist = JSON.parseArray(pointjson,Map.class);
                 //遍历知识点处理年级班级知识点情况
                 for(int j=0;j<pointlist.size();j++){
                         rpointlist.add(pointvo);
                     }
 
-                    setEPaperQuestionPointsStu(gstus,stupoints,subjectid,pointid,pointname);
+                    setEPaperQuestionPointsStu(gstus,stupointlist,subjectid,pointid,pointname);
                 }
             }
         }
         eRclassQtypeMapper.insertList(rtypelist);
-        eRclassQuestionMapper.insertList(rqlist);
+        eRclassQuestionMapper.insertList(rqueslist);
         eRclassQuestionPointMapper.insertList(rpointlist);
-        eRstudentPointMapper.insertList(stupoints);
-        eRstudentQtypeMapper.insertList(stuqtypes);
+        eRstudentPointMapper.insertList(stupointlist);
+        eRstudentQtypeMapper.insertList(stutypelist);
     }
     //处理题库试卷中子母题
     private void setEPaperQtypeForQues(List<EPaperQtypeVo> fjtypelist){
         return false;
     }
     //处理学生选项情况和得分情况
-    private Map setPaperQuestionsForStu(EPaperQtypeQuestionVo q,List<EPaperStudentQuestion> classStu){
+    private Map setPaperQuestionsForStuAnswer(List<EPaperStudentQuestion> classStu){
+        EPaperStudentQuestion q = classStu.get(0);//取第一条数据
+
         Map<String,List<Map>> answermap = new HashMap<>();
         List<Map> goodlist = new ArrayList<>();
         List<Map> badlist = new ArrayList<>();
                 //主观题
                 if(i==0){
                     //处理分数分段对应,用于分数段[0，50%）   [50%，80%）,  [80%，100%]
-                    score8 = ExamUtil.getScoreRateScore(q.getScore(),0.8);
-                    score5 = ExamUtil.getScoreRateScore(q.getScore(),0.8);
-                    key1 = score8+"-"+q.getScore();
+                    score8 = ExamUtil.getScoreRateScore(q.getQscore(),0.8);
+                    score5 = ExamUtil.getScoreRateScore(q.getQscore(),0.8);
+                    key1 = score8+"-"+q.getQscore();
                     key2 = score8 + "-" + score5;
                     key3 = score5 + "-" + 0;
                     answermap.put(key1,new ArrayList<>());
         return rtnmap;
     }
 
+    //设置学生题型下试题得分
+    private void setEPaperQuestionQtypesStu(List<EPaperStudentQuestion> gstus,Map<Integer,ERStudentQtype> stumap){
+        for(EPaperStudentQuestion q : gstus){
+            if(stumap.containsKey(q.getStudentid())){
+                ERStudentQtype sq = stumap.get(q.getStudentid());
+                sq.setStuscore(ExamUtil.add(sq.getStuscore(), q.getStuscore()));
+            }else{
+                ERStudentQtype sq = new ERStudentQtype();
+                sq.setClassid(q.getClassid());
+                sq.setStudentid(q.getStudentid());
+                sq.setStuscore(q.getStuscore());
+            }
+        }
+    }
     //设置学生知识点关联试题得分
     private void setEPaperQuestionPointsStu(List<EPaperStudentQuestion> gstus,List<ERstudentPoint> stupoints,String subjectid,String pointid,String pointname){
         //把试题按学生进行分组然后进行计算
 
 
     }
-
-    //设置学生题型下试题得分
-    private void setEPaperQuestionQtypesStu(List<EPaperStudentQuestion> gstus,List<ERstudentPoint> stupoints){
-
+    //设置学生难易度下试题得分
+    private void setEPaperQuestionComplexitysStu(List<EPaperStudentQuestion> gstus,List<ERstudentPoint> stupoints){
     }
 }

sexam/src/main/java/com/xhkjedu/sexam/vo/report/ERClassScoreVo.java

 public class ERClassScoreVo {
     private Integer stunum;//学生数量
 
-    private Double tcscore = 0.0;//班级得分
+    private Double stuscore = 0.0;//单个试题班级学生下学生得分
+
+    private Double cscore= 0.0;//单个试题班级学生下试题总分
+
 }

sstudy/src/main/java/com/xhkjedu/sstudy/service/question/QuestionService.java

         if(question.getHashear() == null){
             question.setHashear(0);
         }
+        if(question.getSnum() == null){
+            question.setSnum(0);
+        }
 
         saveQues.add(question);
         map.put("questionid",questionid);
                 sq.setCount(0);
                 sq.setQstate(1);
                 sq.setBelong(4);
+                sq.setHashear(0);
                 sq.setQuestionpid(questionid);
                 sq.setSubjectid(question.getSubjectid());
                 sq.setCreateid(question.getCreateid());
                 sonmap.put("sorder",sq.getSorder());
                 sonmap.put("quesitonid",sqid);
                 sonlist.add(sonmap);
-
-                //知识点
-                List<TQuestionPoint> points = sq.getQuestionPoints();
-                if(points!=null && points.size()>0){
-                    for(TQuestionPoint p : points){
-                        TQuestionPoint mp = new TQuestionPoint();
-                        String mqpid = StudyUtil.getId();
-                        mp.setQpid(mqpid);
-                        mp.setQuestionid(questionid);
-                        mp.setPointid(p.getPointid());
-                        mp.setCreateid(question.getCreateid());
-                        mp.setCreatetime(timestamp);
-                        saveQPoints.add(mp);//母题关联所有子题关联知识点
-
-                        //子题关联知识点
-                        String qpid = StudyUtil.getId();
-                        p.setQpid(qpid);
-                        p.setQuestionid(sqid);
-                        p.setCreateid(question.getCreateid());
-                        p.setCreatetime(timestamp);
-                        p.setSchoolid(question.getSchoolid());
-                        saveQPoints.add(p);//子题关联知识点
-                    }
-                }
             }
-        }else{
-            //单题型母题关联知识点
-            //知识点
-            List<TQuestionPoint> points = question.getQuestionPoints();
-            if(points!=null && points.size()>0){
-                for(TQuestionPoint p : points){
-                    p.setQpid(StudyUtil.getId());
-                    p.setQuestionid(questionid);
-                    p.setCreateid(question.getCreateid());
-                    p.setCreatetime(timestamp);
-                    p.setSchoolid(question.getSchoolid());
-                    saveQPoints.add(p);
-                }
+        }
+
+        //单题型母题关联知识点
+        List<TQuestionPoint> points = question.getQuestionPoints();
+        if(points!=null && points.size()>0){
+            for(TQuestionPoint p : points){
+                p.setQpid(StudyUtil.getId());
+                p.setQuestionid(questionid);
+                p.setCreateid(question.getCreateid());
+                p.setCreatetime(timestamp);
+                p.setSchoolid(question.getSchoolid());
+                saveQPoints.add(p);
             }
         }
+
         map.put("sonlist",sonlist);
         return map;
     }
 
-
     //设置章节
     private void setSaveUpdateQuesitonDirector(QuestionVo qvo,TQuestion question,List<TQuestionDirector> saveQDirs){
         //原试题关联章节

sstudy/src/main/java/com/xhkjedu/sstudy/service/question/UserBasketService.java

                     bn.setQtypeid(b.getQtypeid());
                     bn.setQtypename(b.getQtypename());
                     bn.setPtnum(questions.size());
+                    bn.setCtype(b.getCtype());
                     Double ptscore = questions.stream().collect(Collectors.summingDouble(QuestionVo::getScore));
                     bn.setPtscore(ptscore);
                     bn.setQuestions(questions);