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

smarking/src/main/java/com/xhkjedu/smarking/mapper/stupaper/MsPaperStudentMapper.java

 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.exam.MsClassStudent;
 import com.xhkjedu.smarking.model.paper.MsPaperQtype;
+import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
 import com.xhkjedu.smarking.model.stupaper.MsPaperStudent;
 import com.xhkjedu.smarking.model.stupaper.MsPaperStudentScore;
 import com.xhkjedu.smarking.vo.exam.CStudentVo;
     void updateStudentPaperScoreByMpsId(@Param("mpsid") Integer mpsid);
 
     //试学生成绩列表
-    List<MsPaperStudent> listPaperStudentByExamId(@Param("examid") Integer examid,@Param("mpids") List<Integer> mpids);
+    List<MsrStudent> listPaperStudentByExamId(@Param("examid") Integer examid, @Param("mpids") List<Integer> mpids);
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportsubject/MsrSubject.java

     private Double minscore;
     //平均分
     private Double avgscore;
-    //平均成绩排名率
+    //平均成绩排名
     private Integer avgrank;
+    //平均成绩排名率
+    private Double avgrankrate;
     //得分率
     private Double scorerate;
     //总人数

smarking/src/main/java/com/xhkjedu/smarking/model/stupaper/MsPaperStudent.java

     //试题
     @Transient
     List<MsPaperStudentQuestion> questions;
+    @Transient
+    //得分率
+    private Double scorerate;
 
 }

smarking/src/main/java/com/xhkjedu/smarking/service/report/reportother/MsrExamService.java

 
 import com.xhkjedu.smarking.mapper.exam.*;
 import com.xhkjedu.smarking.mapper.report.reportother.MsrExamMapper;
+import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectMapper;
 import com.xhkjedu.smarking.mapper.stupaper.MsPaperStudentMapper;
 import com.xhkjedu.smarking.model.exam.*;
 import com.xhkjedu.smarking.model.paper.MsPaper;
 import com.xhkjedu.smarking.model.report.reportother.MsrExam;
 import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
-import com.xhkjedu.smarking.model.stupaper.MsPaperStudent;
 import com.xhkjedu.smarking.utils.MarkingUtil;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
     private MsClassStudentMapper classStudentMapper;
     @Resource
     private MsPaperStudentMapper paperStudentMapper;
+    @Resource
+    private MsrSubjectMapper msrSubjectMapper;
+    @Resource
+    private MsrStudentMapper msrStudentMapper;
 
     /**
      * @Description 生成报告
         if (N_Utils.isListEmpty(subjects)) return;
         List<MsClass> classes = classMapper.listClassByExamId(examid);//获取考试关联班级
         List<MsClassStudent> students = classStudentMapper.listStudentByExamId(examid);//获取考试关联学生
-        List<Integer> mpids = subjects.stream().map(MsPaper::getMpid).collect(Collectors.toList());
-        List<MsPaperStudent> paperStudents = paperStudentMapper.listPaperStudentByExamId(examid, mpids);//试学生成绩列表
+        List<Integer> mpids = new ArrayList<>();
+        for (MsPaper subject : subjects) {
+            Integer mpid = subject.getMpid();
+            mpids.add(mpid);
+        }
+        List<MsrStudent> paperStudents = paperStudentMapper.listPaperStudentByExamId(examid, mpids);//试学生成绩列表
+        for (MsrStudent student : paperStudents) {
+            student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), student.getFullscore()));
+        }
 
         Integer classnum = N_Utils.obj2Int(classes.stream().map(MsClass::getClassid).distinct().count());
         Integer totalnum = N_Utils.obj2Int(students.stream().map(MsClassStudent::getStudentid).distinct().count());
-        Integer stunum = N_Utils.obj2Int(paperStudents.stream().filter(s -> s.getSstate().equals(2)).map(MsPaperStudent::getStudentid).distinct().count());
+        Integer stunum = N_Utils.obj2Int(paperStudents.stream().filter(s -> s.getSstate().equals(2)).map(MsrStudent::getStudentid).distinct().count());
         Integer missnum = totalnum - stunum;
         double fullscore = subjects.stream().mapToDouble(MsPaper::getPscore).sum();
         List<MsrStudent> schoolStudents = new ArrayList<>();//学校学生成绩
-        List<MsrStudent> schoolSubjectStudents = new ArrayList<>();//学校科目学生成绩
-        List<MsrStudent> classStudents = new ArrayList<>();//班级学生成绩
+        List<MsrStudent> classStudents = new ArrayList<>();//班级学生成绩(总分)
         List<MsrStudent> classSubjectStudents = new ArrayList<>();//班级科目学生成绩
         Map<String, Integer> schoolStuRank = new HashMap<>();//学校学生分数排名
         Map<String, Integer> schoolSubStuRank = new HashMap<>();//学校科目学生分数排名
         Map<String, Integer> classStuRank = new HashMap<>();//班级学生分数排名
         Map<String, Integer> classSubStuRank = new HashMap<>();//班级科目学生分数排名
-        Integer stuzero = exam.getStuzero();
-        Map<Integer, List<MsPaperStudent>> schoolCollect = paperStudents.stream().collect(Collectors.groupingBy(MsPaperStudent::getStudentid));
-        for (Map.Entry<Integer, List<MsPaperStudent>> entry : schoolCollect.entrySet()) {
+        Map<Integer, List<MsrStudent>> schoolCollect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getStudentid));
+        for (Map.Entry<Integer, List<MsrStudent>> entry : schoolCollect.entrySet()) {
             Integer studentid = entry.getKey();
             MsrStudent cs = new MsrStudent();
-            List<MsPaperStudent> list = entry.getValue();
+            List<MsrStudent> list = entry.getValue();
             cs.setClassid(0);
             cs.setStudentid(studentid);
-            cs.setStuscore(list.stream().mapToDouble(MsPaperStudent::getStuscore).sum());
-            cs.setSstate(list.stream().max(Comparator.comparing(MsPaperStudent::getSstate)).get().getSstate());
+            cs.setStuscore(list.stream().mapToDouble(MsrStudent::getStuscore).sum());
+            cs.setSstate(list.stream().max(Comparator.comparing(MsrStudent::getSstate)).get().getSstate());
             cs.setScorerate(N_Utils.getDoubleDivideAndMulitiply(cs.getStuscore(), fullscore));
             schoolStudents.add(cs);
         }
         List<MsrStudent> paperStudents2 = new ArrayList<>();
         Map<String, List<MsClassStudent>> sClassStudent = students.stream().collect(Collectors.groupingBy(s -> s.getSubjectid() + "_" + s.getStudentid()));
-        for (MsPaperStudent paperStudent : paperStudents) {
+        for (MsrStudent paperStudent : paperStudents) {
             String subjectid = paperStudent.getSubjectid();
             Integer studentid = paperStudent.getStudentid();
             Double stuscore = paperStudent.getStuscore();
             }
         }
         String subjectid;
+        Map<String, Double> bjdfMap = new HashMap<>();//班级得分
         Map<Integer, List<MsrStudent>> cCollect = paperStudents2.stream().collect(Collectors.groupingBy(MsrStudent::getClassid));
         for (Map.Entry<Integer, List<MsrStudent>> entry : cCollect.entrySet()) {
             Integer classid = entry.getKey();
                 cs.setStuscore(csEntry.getValue().stream().mapToDouble(MsrStudent::getStuscore).sum());
                 rstudents.add(cs);
             }
+            bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
             setRank(rstudents, classStuRank, 3);//班级学生分数排名
             classStudents.addAll(rstudents);
             Map<String, List<MsrStudent>> subCollect = studentList.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
             for (Map.Entry<String, List<MsrStudent>> ssEntry : subCollect.entrySet()) {
+                subjectid = ssEntry.getKey();
                 rstudents = ssEntry.getValue();
+                bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
                 setRank(rstudents, classSubStuRank, 4);//班级科目学生分数排名
                 classSubjectStudents.addAll(rstudents);
             }
         }
+        setRank(schoolStudents, schoolStuRank, 1);//学校学生分数排名
 
-        List<MsrStudent> schoolStudents2;//参与统计学生列表
-        if (stuzero.equals(0)) {//0分学生不参与统计
-            schoolStudents2 = schoolStudents.stream().filter(s -> s.getStuscore() > 0).collect(Collectors.toList());
-        } else {
-            schoolStudents2 = schoolStudents;
-        }
-        DoubleSummaryStatistics schoolStatistics = schoolStudents2.stream().filter(s -> s.getStuscore() > 0).mapToDouble(MsrStudent::getStuscore).summaryStatistics();
+        List<MsrStudent> schoolStudents2 = schoolStudents.stream().filter(s -> s.getSstate().equals(2)).collect(Collectors.toList());//参与统计学生列表
+        DoubleSummaryStatistics schoolStatistics = schoolStudents2.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
         double schoolStatisticsMax = N_Utils.handleInfinity(schoolStatistics.getMax());
         //最低分均不包括0分
-        double schoolStatisticsMin = N_Utils.handleInfinity(schoolStudents2.stream().filter(s -> s.getStuscore() > 0).mapToDouble(MsrStudent::getStuscore).summaryStatistics().getMin());
+        double schoolStatisticsMin = N_Utils.handleInfinity(schoolStatistics.getMin());
         double schoolStatisticsAverage = N_Utils.formatDouble(schoolStatistics.getAverage(), 2);
 
         //总体分析
         msrExamMapper.insert(msrExam);
 
         //科目分析
-        Map<String, List<MsPaperStudent>> subjectCollect = paperStudents.stream().collect(Collectors.groupingBy(MsPaperStudent::getSubjectid));
+        Map<String, MsrSubject> subjectMap = new HashMap<>();//科目分析map
+        Map<String, List<MsrStudent>> subjectCollect = paperStudents.stream().collect(Collectors.groupingBy(MsrStudent::getSubjectid));
         List<MsrSubject> msrSubjects = new ArrayList<>();
         MsrSubject msrSubject = new MsrSubject();
         msrSubject.setExamid(examid);
-        msrSubject.setSubjectid("zf");
+        subjectid = "zf";
+        msrSubject.setSubjectid(subjectid);
         msrSubject.setSubjectname("总分");
         msrSubject.setFullscore(fullscore);
         msrSubject.setMaxscore(schoolStatisticsMax);
         msrSubject.setMinscore(schoolStatisticsMin);
         msrSubject.setAvgscore(schoolStatisticsAverage);
-        msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(schoolStatisticsAverage, fullscore));
-        List<Double> scores = schoolStudents2.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
-        double bzc = MarkingUtil.bzc(scores);
-        msrSubject.setBzc(bzc);
-        msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, schoolStatisticsAverage));
-        msrSubject.setNd(MarkingUtil.div(schoolStatisticsAverage, fullscore));
-        msrSubject.setQfd(MarkingUtil.qfd(scores));
-        List<Double> scoreRates = schoolStudents2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
-        double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
-        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, schoolStatisticsAverage));
-        msrSubject.setDfllc(dfllc);
         msrSubject.setTotalnum(totalnum);
         msrSubject.setStunum(stunum);
         msrSubject.setMissnum(missnum);
+        setSubject(msrSubject, schoolStudents2);
         msrSubjects.add(msrSubject);
+        subjectMap.put(subjectid, msrSubject);
         for (MsPaper subject : subjects) {
+            subjectid = subject.getSubjectid();
             msrSubject = new MsrSubject();
             msrSubject.setExamid(examid);
-            msrSubject.setSubjectid(subject.getSubjectid());
+            msrSubject.setSubjectid(subjectid);
             msrSubject.setSubjectname(subject.getSubjectname());
             msrSubject.setFullscore(subject.getPscore());
-            List<MsPaperStudent> studentList = subjectCollect.get(subject.getSubjectid());
+            List<MsrStudent> studentList = subjectCollect.get(subjectid);
+            setRank(studentList, schoolSubStuRank, 2);//学校科目学生分数排名
+            List<MsrStudent> studentList2 = studentList.stream().filter(s -> s.getSstate().equals(2)).collect(Collectors.toList());//参与统计学生列表
+            totalnum = studentList.size();
+            stunum = studentList2.size();
+            missnum = totalnum - stunum;
+            msrSubject.setTotalnum(totalnum);
+            msrSubject.setStunum(stunum);
+            msrSubject.setMissnum(missnum);
+            DoubleSummaryStatistics subjectStatistics = studentList2.stream().mapToDouble(MsrStudent::getStuscore).summaryStatistics();
+            double subjectStatisticsMax = N_Utils.handleInfinity(subjectStatistics.getMax());
+            //最低分均不包括0分
+            double subjectStatisticsMin = N_Utils.handleInfinity(subjectStatistics.getMin());
+            double subjectStatisticsAverage = N_Utils.formatDouble(subjectStatistics.getAverage(), 2);
+            msrSubject.setMaxscore(subjectStatisticsMax);
+            msrSubject.setMinscore(subjectStatisticsMin);
+            msrSubject.setAvgscore(subjectStatisticsAverage);
+            setSubject(msrSubject, studentList2);
             msrSubjects.add(msrSubject);
+            subjectMap.put(subjectid, msrSubject);
+        }
+        List<Double> avgScores = msrSubjects.stream().map(MsrSubject::getAvgscore).sorted().collect(Collectors.toList());
+        Map<Double, Integer> fspm = MarkingUtil.fspm(avgScores);//平均分排名
+        for (MsrSubject subject : msrSubjects) {
+            subject.setAvgrank(fspm.get(subject.getAvgscore()));
+            subject.setAvgrankrate(MarkingUtil.div(subject.getAvgrank(), subject.getTotalnum()));
+        }
+        msrSubjectMapper.insertList(msrSubjects);
+
+        //学生成绩分析
+        for (MsrStudent student : classStudents) {
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
+        }
+        for (MsrStudent student : classSubjectStudents) {
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
         }
+        if (N_Utils.isListNotEmpty(classStudents)) msrStudentMapper.insertList(classStudents);
+        if (N_Utils.isListNotEmpty(classSubjectStudents)) msrStudentMapper.insertList(classSubjectStudents);
 
         examMapper.updateExamState(examid, 3);
     }
 
+    //设置科目分析计算参数
+    private void setSubject(MsrSubject msrSubject, List<MsrStudent> schoolStudents2) {
+        Double avgscore = msrSubject.getAvgscore();
+        Double fullscore = msrSubject.getFullscore();
+        msrSubject.setScorerate(N_Utils.getDoubleDivideAndMulitiply(avgscore, fullscore));
+        List<Double> scores = schoolStudents2.stream().map(MsrStudent::getStuscore).sorted().collect(Collectors.toList());
+        double bzc = MarkingUtil.bzc(scores);
+        msrSubject.setBzc(bzc);
+        msrSubject.setCyxs(N_Utils.getDoubleDivideAndMulitiply(bzc, avgscore));
+        msrSubject.setNd(MarkingUtil.div(avgscore, fullscore));
+        msrSubject.setQfd(MarkingUtil.qfd(scores));
+        List<Double> scoreRates = schoolStudents2.stream().map(MsrStudent::getScorerate).sorted().collect(Collectors.toList());
+        double dfllc = MarkingUtil.sub(scoreRates.get(scoreRates.size() - 1), scoreRates.get(0));
+        msrSubject.setDfllc(dfllc);
+        msrSubject.setDflxdlc(MarkingUtil.div(dfllc, avgscore));
+        msrSubject.setEsscore(MarkingUtil.cynjdf(scores, 0.2));
+        msrSubject.setSsscore(MarkingUtil.cynjdf(scores, 0.4));
+        msrSubject.setLsscore(MarkingUtil.cynjdf(scores, 0.6));
+        msrSubject.setBsscore(MarkingUtil.cynjdf(scores, 0.8));
+    }
+
+    //设置学生分析计算参数
+    private void setStudent(MsrStudent student, Map<String, Integer> classStuRank, Map<String, Integer> schoolStuRank
+            , Map<String, Integer> classSubStuRank, Map<String, Integer> schoolSubStuRank
+            , Map<String, Double> bjdfMap, Map<String, MsrSubject> subjectMap) {
+        String subjectid;
+        Integer classid = student.getClassid();
+        Integer studentid = student.getStudentid();
+        subjectid = student.getSubjectid();
+        MsrSubject msrSubject = subjectMap.get(subjectid);
+        Double pjf = msrSubject.getAvgscore();//年级平均分
+        student.setBzf(MarkingUtil.bzf(bjdfMap.get(classid + "_" + subjectid), pjf, msrSubject.getBzc()));
+        Integer classrank;
+        Integer schoolrank;
+        if (subjectid.equals("zf")) {
+            classrank = classStuRank.get(classid + "_" + studentid);
+            schoolrank = schoolStuRank.get(studentid.toString());
+        } else {
+            classrank = classSubStuRank.get(classid + "_" + subjectid + "_" + studentid);
+            schoolrank = schoolSubStuRank.get(subjectid + "_" + studentid);
+        }
+        student.setCjl(MarkingUtil.cjl(student.getStuscore(), pjf));
+        student.setClassrank(classrank);
+        student.setSchoolrank(schoolrank);
+        double rankrate = MarkingUtil.div(schoolrank, msrSubject.getTotalnum());
+        student.setRankrate(rankrate);//个人成绩排名率=自己所在学科成绩分数的名次/总人数
+        student.setXkqrz(MarkingUtil.sub(msrSubject.getAvgrank(), rankrate));//学科强弱值 = 平均成绩排名率- 个人成绩排名率
+    }
+
     //分数排名
     private void setRank(List<MsrStudent> students, Map<String, Integer> rank, Integer code) {
         List<Map.Entry<Double, List<MsrStudent>>> gslist2 = students.stream()

smarking/src/main/java/com/xhkjedu/smarking/utils/MarkingUtil.java

 
     }
 
+    //处于年级20%得分(v=0.2)
+    public static Double cynjdf(List<Double> scores, double v) {
+        if (N_Utils.isListEmpty(scores)) return 0.0;
+        int totalCount = scores.size();
+        int topCount = (int) Math.ceil(totalCount * v); // 计算
+        return scores.get(totalCount - topCount);
+    }
+
+    //分数排名
+    public static Map<Double,Integer> fspm(List<Double> scores) {
+        // 创建一个地图来存储分数和出现次数
+        Map<Double, Integer> scoreCountMap = new HashMap<>();
+
+        // 遍历 scores 计算分数出现的次数
+        for (Double score : scores) {
+            scoreCountMap.put(score, scoreCountMap.getOrDefault(score, 0) + 1);
+        }
+        return scoreCountMap;
+    }
 
 }

smarking/src/main/resources/mapper/exam/MsSubjectMapper.xml

     <select id="listReportSubject" resultType="com.xhkjedu.smarking.model.paper.MsPaper">
         select s.subjectid,s.subjectname,p.mpid,p.pnum,p.mergepnum,p.pscore,p.correcttype,p.ptype
         from ms_subject s inner join ms_paper p on s.msid=p.msid
-        where s.examid=#{examid}
+        where s.examid=#{examid} and s.msid=2
         <if test="exammode!=3">
             and s.msstate=2
         </if>

smarking/src/main/resources/mapper/stupaper/MsPaperStudentMapper.xml

         select * from ms_paper_student where examid=#{examid} and studentid=#{studentid}
     </select>
     <!--考试学生成绩列表-->
-    <select id="listPaperStudentByExamId" resultType="com.xhkjedu.smarking.model.stupaper.MsPaperStudent">
-        select mpid,subjectid,studentid,stuscore
+    <select id="listPaperStudentByExamId" resultType="com.xhkjedu.smarking.model.report.reportstu.MsrStudent">
+        select mpid,subjectid,studentid,stuscore,sstate,pscore as fullscore
         from ms_paper_student where examid=#{examid}
-        <foreach collection="mpids" item="mpid" separator="and mpid in (">
+        <foreach collection="mpids" item="mpid" open="and mpid in (" separator="," close=")">
             #{mpid}
         </foreach>
     </select>