小题分析

smarking/src/main/java/com/xhkjedu/smarking/mapper/paper/MsPaperQtypeQuestionMapper.java

     int updateBatchQuestionCoor(@Param("list") List<MsPaperQtypeQuestion> list);
     //清空试题切割坐标
     int updateQuestionCoorByMpid(@Param("mpid")Integer mpid);
+    //试卷中所有试题-考试报告
+    List<MsPaperQtypeQuestion> listQuestionsForReport(@Param("mpid")Integer mpid);
 
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportother/MsrReportparamMapper.java

 
 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
-import com.xhkjedu.smarking.vo.report.reportother.ReportParams;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
 public interface MsrReportparamMapper extends TkMapper<MsrReportparam> {
 
     //获取考试指定图例对应参数
-    List<MsrReportparam> listReportparamByRpbelong(@Param("rp") ReportParams reportParams);
+    List<MsrReportparam> listReportparamByRpbelong(@Param("examid") Integer examid, @Param("rpbelong") String rpbelong, @Param("reportcode") String reportcode);
 
     //批量删除
     int deleteBatchReportparam(@Param("list") List<Integer> list);

smarking/src/main/java/com/xhkjedu/smarking/model/paper/MsPaperQtypeQuestion.java

     //试题知识点
     @Transient
     private List<MsPaperQtypeQuestionPoint> points;
+
+    @Transient
+    private String mptqn;//大题题号
+    @Transient
+    private Integer mptnum;//题型下试题数量
+    @Transient
+    private Double mptscore;//题型下试题分值
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportclass/MsrClassQtype.java

     //满分
     private Double fullscore;
     //满分人数
-    private Integer fullnum;
+    private Integer mfnum;
     //满分人ids
-    private String fullids;
+    private String mfids;
     //满人人数占比
-    private Double fullrate;
+    private Double mfrate;
     //零分人数
-    private Integer zeronum;
+    private Integer lfnum;
     //零分人ids
-    private String zeroids;
+    private String lfids;
     //零分人数占比
-    private Double zerorate;
+    private Double lfrate;
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportclass/MsrClassQuestion.java

     private Integer cqid;
     //考试ID
     private Integer examid;
-    //科目ID（含总分）
+    //科目ID
     private String subjectid;
     //班级ID（含全体）
     private Integer classid;
     //标准差
     private Double bzc;
     //差异系数
-    private Double cxxs;
+    private Double cyxs;
     //区分度
     private Double qfd;
     //区分度描述
     private Double zqrate;
     //零分人数
     private Integer lfnum;
+    //零分人数ID
+    private String lfids;
     //零分率
     private Double lfrate;
     //满分人数
     private Integer mfnum;
+    //满分人数ID
+    private String mfids;
     //满分人数占比
     private Double mfrate;
 }

smarking/src/main/java/com/xhkjedu/smarking/model/report/reportclass/MsrClassQuestionObj.java

     @Id
     //阅卷报告-班级试题小题分析-客观题答案分析ID
     private Integer cqoid;
-    //班级试题小题分析表ID
-    private Integer cqid;
+    //考试ID
+    private Integer examid;
+    //科目ID
+    private String subjectid;
+    //班级ID（含全体）
+    private Integer classid;
+    //试卷试题id
+    private Integer mptqid;
     //选项答案
     private String xxda;
     //人数
-    private Integer onum;
+    private Integer xxnum;
     //比例
-    private Double orate;
+    private Double xxrate;
     //生学id字符串
     private String stuids;
 }

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

     //满分
     private Double fullscore;
     //满分人数
-    private Integer fullnum;
+    private Integer mfnum;
     //满分人数ids
-    private String fullids;
+    private String mfids;
     //零分人数
-    private Integer zeronum;
+    private Integer lfnum;
     //零分人数id
-    private String zeroids;
+    private String lfids;
     //最高分
     private Double maxscore;
     //最低分

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

     private Integer hasanswer;//试卷是否设置了正确
     @Transient
     private String qanswer;//试题正确答案
-    @Transient
-    private Integer qtype;//类型1客观题2主观题
-    @Transient
-    private String mptqn;//题型题号
 }

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

 package com.xhkjedu.smarking.service.report.generate;
 
+import com.alibaba.fastjson.JSON;
+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.reportother.MsrReportparamMapper;
 import com.xhkjedu.smarking.mapper.stupaper.MsPaperStudentQuestionMapper;
+import com.xhkjedu.smarking.model.exam.MsClassStudent;
+import com.xhkjedu.smarking.model.paper.MsPaper;
+import com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion;
+import com.xhkjedu.smarking.model.report.reportclass.MsrClassQuestion;
+import com.xhkjedu.smarking.model.report.reportother.MsrReportparam;
 import com.xhkjedu.smarking.model.stupaper.MsPaperStudentQuestion;
+import com.xhkjedu.smarking.utils.MarkingUtil;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @Description：试题对应报告内容
 public class ReportGenerateQuestionService {
     @Resource
     private MsPaperStudentQuestionMapper msPaperStudentQuestionMapper;
+    @Resource
+    private MsClassStudentMapper msClassStudentMapper;
+    @Resource
+    private MsSubjectMapper msSubjectMapper;
+    @Resource
+    private MsPaperQtypeQuestionMapper msPaperQtypeQuestionMapper;
+    @Resource
+    private MsrReportparamMapper msrReportparamMapper;
 
-    public void generateQuestion(Integer examid){
+    public void generateQuestion(Integer examid,Integer exammode){
         //查询所有学生试题
         List<MsPaperStudentQuestion> stuQuestions = msPaperStudentQuestionMapper.listAllStuQuesByExamid(examid);
+        List<MsClassStudent> classStudents = msClassStudentMapper.listStudentByExamId(examid);
+        List<MsPaper> subjects = msSubjectMapper.listReportSubject(examid, exammode);
+        //获取考试参数
+        List<MsrReportparam> params = msrReportparamMapper.listReportparamByRpbelong(examid,"quesummary",null);
+
+        //根据科目进行区分
+        for(MsPaper subject : subjects){
+            String subjectid = subject.getSubjectid();
+            //获取科目下所有学生试题
+            List<MsPaperStudentQuestion> subjectStuQuestions = stuQuestions.stream().filter(stuQuestion -> stuQuestion.getSubjectid().equals(subjectid)).collect(Collectors.toList());
+            //科目下所有班级学生
+            List<MsClassStudent> subjectClassStudents = classStudents.stream().filter(classStudent -> classStudent.getSubjectid().equals(subjectid)).collect(Collectors.toList());
+            //获取试卷中所有小题基础信息包含大题信息
+            List<MsPaperQtypeQuestion> questions = msPaperQtypeQuestionMapper.listQuestionsForReport(subject.getMpid());
+
+            List<MsrReportparam> subjectParams = params.stream().filter(p -> p.getRpbelong().equals(subjectid)).collect(Collectors.toList());
+        }
+    }
+
+    //处理单个试题分析
+    private void handleQuestion(List<MsPaperStudentQuestion> subjectStuQuestions, List<MsClassStudent> subjectClassStudents,List<MsPaperQtypeQuestion> questions,List<MsrReportparam> params,Integer examid,String subjectid){
+
+        List<MsrClassQuestion> saveQuestions = new ArrayList<>();//小题分析
+
+        //处理小题信息
+        for(MsPaperQtypeQuestion question : questions){
+            //获取第一小题所有作答情况，全校作答情况
+            List<MsPaperStudentQuestion> stuQuestions = subjectStuQuestions.stream().filter(q -> q.getMptqid().equals(question.getMptqid())).collect(Collectors.toList());
+            int stunum = stuQuestions.size();//学生数量
+            Double sumQScore = question.getQscore() * stunum;//小题得分
+            List<Double> stuScores = stuQuestions.stream().map(q -> q.getStuscore()).collect(Collectors.toList());//所有学生得分
+
+            Double maxScore = stuQuestions.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).max().orElse(0.0);//最高分
+            Double minScore = stuQuestions.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).min().orElse(0.0);//最低分
+            Double avgScore = MarkingUtil.calculateAverage(stuScores);//平均分
+            Double avgScoreRate = MarkingUtil.calculateRate(avgScore,sumQScore);//平均得分率
+
+            MsrClassQuestion schoolQ = new MsrClassQuestion();
+            schoolQ.setClassid(0);//全体班级
+            schoolQ.setExamid(examid);
+            schoolQ.setSubjectid(subjectid);
+            schoolQ.setSchoolmaxscore(maxScore);
+            schoolQ.setSchoolminscore(minScore);
+            schoolQ.setSchoolavgscore(avgScore);
+            schoolQ.setSchoolavgrate(avgScoreRate);
+            //班级试题情况
+            MsrClassQuestion schoolQue = handleQuestionClass(stuQuestions,question,params,schoolQ);
+            saveQuestions.add(schoolQue);
+
+            //班级试题--客观题选项情况
+
+
+            //处理班级情况
+            for(MsClassStudent classStudent : subjectClassStudents){
+                //获取班级下学生id
+                List<Integer> classStuIds = subjectClassStudents.stream().map(MsClassStudent::getStudentid).collect(Collectors.toList());
+                //获取班级下学生试题
+                List<MsPaperStudentQuestion> classStuQuestions = stuQuestions.stream().filter(q -> classStuIds.contains(q.getStudentid())).collect(Collectors.toList());
+                MsrClassQuestion classQue = handleQuestionClass(classStuQuestions,question,params,schoolQ);
+                saveQuestions.add(classQue);
+            }
+
+
+        }
+    }
+
+    //处理单个试题分析-学校、班级分析
+    private MsrClassQuestion handleQuestionClass(List<MsPaperStudentQuestion> stuQuestions,MsPaperQtypeQuestion question,List<MsrReportparam> params,MsrClassQuestion schoolQ){
+        int stunum = stuQuestions.size();//学生数量
+        Double qScore = question.getQscore();//试题分值
+        Double sumQScore = question.getQscore() * stunum;//小题得分
+        List<Double> stuScores = stuQuestions.stream().map(q -> q.getStuscore()).collect(Collectors.toList());//所有学生得分
+        Double sumStuScore = stuQuestions.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).sum();//综合
+
+        Double maxScore;//最高分
+        Double minScore;//最低分
+        Double avgScore;//平均分
+        Double avgScoreRate;//平均得分率
+        if(schoolQ.getClassid() == 0){
+            //代表是校级
+            maxScore = schoolQ.getSchoolmaxscore();
+            minScore = schoolQ.getSchoolminscore();
+            avgScore = schoolQ.getSchoolavgscore();
+            avgScoreRate = schoolQ.getSchoolavgrate();
+        }else{
+            //指定班级
+            maxScore = stuQuestions.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).max().orElse(0.0);//最高分
+            minScore = stuQuestions.stream().mapToDouble(MsPaperStudentQuestion::getStuscore).min().orElse(0.0);//最低分
+            avgScore = MarkingUtil.calculateAverage(stuScores);//平均分
+            avgScoreRate = MarkingUtil.calculateRate(avgScore,sumQScore);//平均得分率
+        }
+        Double stuScoreRate = MarkingUtil.calculateRate(sumStuScore,sumQScore);//学生得分率
+        MsrClassQuestion classQ = new MsrClassQuestion();
+        classQ.setExamid(schoolQ.getExamid());
+        classQ.setSubjectid(schoolQ.getSubjectid());
+        classQ.setClassid(schoolQ.getClassid());//班级id
+        classQ.setMptqid(question.getMptqid());
+        classQ.setQtype(question.getQtype());
+        classQ.setQn(question.getMptqn() + "." + question.getQn());
+        classQ.setFullscore(question.getQscore());
+        classQ.setStunum(stunum);
+        classQ.setClassmaxscore(maxScore);
+        classQ.setClassminscore(minScore);
+        classQ.setClassavgscore(avgScore);
+        classQ.setClassavgrate(avgScoreRate);
+
+        classQ.setSchoolmaxscore(schoolQ.getSchoolmaxscore());
+        classQ.setSchoolminscore(schoolQ.getSchoolminscore());
+        classQ.setSchoolavgscore(schoolQ.getSchoolavgscore());
+        classQ.setSchoolavgrate(schoolQ.getSchoolavgrate());
+
+        classQ.setScorerate(stuScoreRate);
+        classQ.setScoreratec(MarkingUtil.sub(MarkingUtil.calculateRate(maxScore,qScore),MarkingUtil.calculateRate(minScore,qScore)));//得分率差=最高得分率-最低得分率
+        classQ.setNd(MarkingUtil.div(stuScoreRate,qScore));//难度
+        classQ.setNdms(handleQuestionNdAndQfd(params,1,classQ.getNd()));//难度描述
+        classQ.setQfd(MarkingUtil.qfd(stuScores));//区分度
+        classQ.setQfdms(handleQuestionNdAndQfd(params,2, classQ.getQfd()));//区分度描述
+        classQ.setBzc(MarkingUtil.bzc(stuScores));//标准差
+        classQ.setCyxs(MarkingUtil.div(classQ.getBzc(),avgScore));//差异系数
+        classQ.setJbzs(MarkingUtil.jbzs(stuScores,stuScoreRate));//鉴别指数
+        //获取所有满分学生
+        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.setMfids(mfids);
+        //获取零分学生
+        List<MsPaperStudentQuestion> lfStuQuestions = stuQuestions.stream().filter(q -> q.getStuscore().equals(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.setLfids(lfids);
+        return classQ;
+    }
 
+    private String handleQuestionNdAndQfd(List<MsrReportparam> params,Integer rptype,Double nd){
+        //获取难度或者区分度
+        MsrReportparam ndParam = params.stream().filter(p -> p.getRptype().equals(rptype)).findFirst().orElse(null);//难度
+        String ndms = "";
+        if(ndParam!= null){
+            List<SzJsonVo> szList = JSON.parseArray(ndParam.getSzjson(), SzJsonVo.class);
+            for (SzJsonVo sz : szList) {
+                if (nd == 1 && sz.getMaxvalue() == 1) {
+                    ndms = sz.getDjkey();
+                    break;
+                } else if (nd == 0 && sz.getMinvalue() == 0) {
+                    ndms = sz.getDjkey();
+                    break;
+                } else if(nd >= sz.getMinvalue() && nd < sz.getMaxvalue()) {
+                    ndms = sz.getDjkey();
+                    break;
+                }
+            }
+        }
+        return ndms;
     }
 }

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

      **/
     @Transactional(rollbackFor = Exception.class)
     public void saveReportparam(ReportParams reportParams) {
-        List<MsrReportparam> originalParams = msrReportparamMapper.listReportparamByRpbelong(reportParams);
+        List<MsrReportparam> originalParams = msrReportparamMapper.listReportparamByRpbelong(reportParams.getExamid(),reportParams.getRpbelong(),reportParams.getReportcode());
 
         Integer timestamp = N_Utils.getSecondTimestamp();
         List<MsrReportparam> params = reportParams.getParams();
      * @Return java.util.List<com.xhkjedu.smarking.model.report.reportother.MsrReportparam>
      **/
     public List<MsrReportparam> listReportparamByRpbelong(ReportParams reportParams) {
-        return msrReportparamMapper.listReportparamByRpbelong(reportParams);
+        return msrReportparamMapper.listReportparamByRpbelong(reportParams.getExamid(),reportParams.getRpbelong(),reportParams.getReportcode());
     }
 
     /*
      **/
     public List<MsrReportparam> initReportparam(Integer schoolid,Integer gradeid,Integer examid,Integer handleid) {
         //初始化时判断参数是否已经存在
-        ReportParams ep = new ReportParams();
-        ep.setExamid(examid);
-        List<MsrReportparam> examParams = msrReportparamMapper.listReportparamByRpbelong(ep);
+        List<MsrReportparam> examParams = msrReportparamMapper.listReportparamByRpbelong(examid,null,null);
         if(examParams!= null && examParams.size() > 0){
             //说明考试已经有参数存在
             return examParams;

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

 import com.alibaba.fastjson.JSONArray;
 import com.xhkjedu.smarking.config.ConfigKey;
 import com.xhkjedu.smarking.vo.paper.PaperFileVo;
+import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
 import com.xhkjedu.utils.N_Utils;
 import com.xhkjedu.vo.ResultVo;
 import lombok.extern.slf4j.Slf4j;
 
     /**
      * 删除Html标签
-     *
      */
     public static String htmlRemoveTag(String inputString) {
         if (inputString == null)
         java.util.regex.Pattern p_html;
         java.util.regex.Matcher m_html;
         try {
-            //定义script的正则表达式{或<script[^>]*?>[\\s\\S]*?<\\/script>
+            // 定义script的正则表达式{或<script[^>]*?>[\\s\\S]*?<\\/script>
             String regEx_script = "<[\\s]*?script[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?script[\\s]*?>";
-            //定义style的正则表达式{或<style[^>]*?>[\\s\\S]*?<\\/style>
+            // 定义style的正则表达式{或<style[^>]*?>[\\s\\S]*?<\\/style>
             String regEx_style = "<[\\s]*?style[^>]*?>[\\s\\S]*?<[\\s]*?\\/[\\s]*?style[\\s]*?>";
             String regEx_html = "<[^>]+>"; // 定义HTML标签的正则表达式
             p_script = Pattern.compile(regEx_script, Pattern.CASE_INSENSITIVE);
      * @Param [str1, str2]
      * @Return int
      **/
-    public static int isEqualStringCheck(String str1,String str2){
+    public static int isEqualStringCheck(String str1, String str2) {
         char[] charArray1 = str1.toCharArray();
         char[] charArray2 = str2.toCharArray();
         Arrays.sort(charArray1);
         Arrays.sort(charArray2);
-        int eqResult = 0;//0代表不相等 1表示两个字符串相等 2代表字符串1包含字符串2
-        if(Arrays.equals(charArray1, charArray2)){
+        int eqResult = 0;// 0代表不相等 1表示两个字符串相等 2代表字符串1包含字符串2
+        if (Arrays.equals(charArray1, charArray2)) {
             eqResult = 1;
         }
 
-        if(Collections.singletonList(charArray1).contains(charArray2)){
+        if (Collections.singletonList(charArray1).contains(charArray2)) {
             eqResult = 2;
         }
 
      * @Param [stuanswer, q]
      * @Return java.lang.Double
      **/
-    public static Double checkObjectiveStuAnswer(String stuanswer, int ctype,String qanswer,Double loseoption,Double qscore){
-        String qanswerCort = JSON.parseArray(qanswer, String.class).get(0);//试题正确答案
+    public static Double checkObjectiveStuAnswer(String stuanswer, int ctype, String qanswer, Double loseoption, Double qscore) {
+        String qanswerCort = JSON.parseArray(qanswer, String.class).get(0);// 试题正确答案
         Double stuscore = 0D;
-        if(N_Utils.isNotEmpty(stuanswer)){
-            if(ctype == 1 || ctype == 4 || ctype == 5 || ctype == 6){
-                if(qanswerCort.equalsIgnoreCase(stuanswer)){
+        if (N_Utils.isNotEmpty(stuanswer)) {
+            if (ctype == 1 || ctype == 4 || ctype == 5 || ctype == 6) {
+                if (qanswerCort.equalsIgnoreCase(stuanswer)) {
                     stuscore = qscore;
                 }
-            }else if(ctype == 2){
-                //多选题进行判断，
+            } else if (ctype == 2) {
+                // 多选题进行判断，
                 int isEqualStr = isEqualStringCheck(qanswerCort, stuanswer);
-                if(isEqualStr == 1){
+                if (isEqualStr == 1) {
                     stuscore = qscore;
-                }else if(isEqualStr == 2){
-                    stuscore = loseoption;//少选得分
+                } else if (isEqualStr == 2) {
+                    stuscore = loseoption;// 少选得分
                 }
             }
         }
         return b1.add(b2).doubleValue();
     }
 
-    //两数相减
+    // 两数相减
     public static long subtract(long a, long b) {
         BigInteger biginta = new BigInteger(a + "");
         BigInteger bigintb = new BigInteger(b + "");
 
     }
 
-    //两数相减
+    // 两数相减
     public static Integer subtractInt(Integer a, Integer b) {
         BigInteger biginta = new BigInteger(a + "");
         BigInteger bigintb = new BigInteger(b + "");
 
     /**
      * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到 小数点以后2位，以后的数字舍弃。
+     *
      * @param v1 被除数
      * @param v2 除数
      * @return 两个参数的商
 
     /**
      * 向上取值
-     * @param score 原始得分
+     *
+     * @param score    原始得分
      * @param interval 取值间隔
      * @return 向上取值后的结果
      */
 
     /**
      * 向下取值
-     * @param score 原始得分
+     *
+     * @param score    原始得分
      * @param interval 取值间隔
      * @return 向下取值后的结果
      */
 
     /**
      * 计算总分并处理超过满分的情况
-     * @param scores 得分数组
+     *
+     * @param scores   得分数组
      * @param interval 取值间隔
      * @param maxScore 满分
      * @return 最终总分
 
     /**
      * 计算两个分数之间的分差
+     *
      * @param score1 第一个分数
      * @param score2 第二个分数
      * @return 分差
         return b1.subtract(b2).doubleValue();
     }
 
-    //字符串转为时间戳(秒)
+    // 字符串转为时间戳(秒)
     public static long strToTimestamp(String str) {
         if (str == null || str.isEmpty()) return 0;
         DateTimeFormatter ftf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
      * @Author wn
      * @Date 2022/10/27 11:36
      **/
-    public static long getTimestrToTimetamp(String time){
+    public static long getTimestrToTimetamp(String time) {
         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         Date date = new Date();
         try {
             date = sdf.parse(time);
-        }catch (Exception e){
+        } catch (Exception e) {
             log.error("字符串转时间戳出错：" + e.getMessage());
         }
-        return date.getTime()/1000;
+        return date.getTime() / 1000;
     }
 
     /*
      * @Param [stupic, merged, saveFloder]
      * @Return java.lang.String
      **/
-    public static String uploadBase64Img(String stupic,Integer merged,String saveFloder) {
+    public static String uploadBase64Img(String stupic, Integer merged, String saveFloder) {
         String apiMethod;
-        if(merged == 1){
-            //说明上传的图片为单张保存
+        if (merged == 1) {
+            // 说明上传的图片为单张保存
             apiMethod = "bs/base";
-        }else{
-            //上传的多张图片需要合并为一张
+        } else {
+            // 上传的多张图片需要合并为一张
             apiMethod = "bs/mbase_merge";
         }
-        String stubase64;//防止内容被更改
+        String stubase64;// 防止内容被更改
         try {
             stubase64 = URLEncoder.encode(stupic, "UTF-8");
         } catch (UnsupportedEncodingException e) {
             log.error("base64格式化内容出错" + e.getMessage());
             throw new RuntimeException(e);
         }
-        //处理字段那种图片路径,base64转图片
+        // 处理字段那种图片路径,base64转图片
         String params = "base64path=" + stubase64 + "&savefolder=" + saveFloder;
         String fileInfoStr = N_Utils.sendPost(ConfigKey.fileapi + apiMethod, params);
-        if(N_Utils.isEmpty(fileInfoStr)){
+        if (N_Utils.isEmpty(fileInfoStr)) {
             return "";
         }
         ResultVo fileResult = JSON.parseObject(fileInfoStr, ResultVo.class);
         if (fileResult.getCode() == 0 && N_Utils.isNotEmpty(fileResult.getObj())) {
             return fileResult.getObj().toString();
-        }else{
+        } else {
             return "";
         }
     }
      * @Param [stupic, saveFloder]
      * @Return java.util.List<java.lang.String>
      **/
-    public static PaperFileVo uploadBatchBase64ImgPdf(List<String> imgList, String saveFloder){
-        //处理字段那种图片路径,base64转图片
+    public static PaperFileVo uploadBatchBase64ImgPdf(List<String> imgList, String saveFloder) {
+        // 处理字段那种图片路径,base64转图片
         String base64path = JSON.toJSONString(imgList);
         try {
             base64path = URLEncoder.encode(base64path, "UTF-8");
         ResultVo fileResult = JSON.parseObject(fileInfoStr, ResultVo.class);
         if (fileResult.getCode() == 0 && N_Utils.isNotEmpty(fileResult.getObj())) {
             return JSONArray.parseObject(fileResult.getObj().toString(), PaperFileVo.class);
-        }else{
+        } else {
             return null;
         }
     }
         Matcher matcher = pattern.matcher(input);
 
         while (matcher.find()) {
-            if (matcher.group(1)!= null) {
+            if (matcher.group(1) != null) {
                 result.add(matcher.group(1));
-            } else if (matcher.group(2)!= null) {
+            } else if (matcher.group(2) != null) {
                 String str = matcher.group(2);
-                for(char c : str.toCharArray()){
-                    result.add(c+"");
+                for (char c : str.toCharArray()) {
+                    result.add(c + "");
                 }
             }
         }
         return result;
     }
 
-    public static String[] qnArr = {"一","二","三","四","五","六","七","八","九","十","十一","十二","十三","十四","十五","十六","十七","十八","十九","二十",
-            "二十一","二十二","二十三","二十四","二十五","二十六","二十七","二十八","二十九","三十"};
+    public static String[] qnArr = {"一", "二", "三", "四", "五", "六", "七", "八", "九", "十", "十一", "十二", "十三", "十四", "十五", "十六", "十七", "十八", "十九", "二十",
+            "二十一", "二十二", "二十三", "二十四", "二十五", "二十六", "二十七", "二十八", "二十九", "三十"};
 
-    //获取题号
-    public static String getQnByOrder(Integer qorder){
+    // 获取题号
+    public static String getQnByOrder(Integer qorder) {
         String rtnStr;
-        if(qorder == null || qorder == 0 || qorder > 30){
+        if (qorder == null || qorder == 0 || qorder > 30) {
             rtnStr = qnArr[0];
         }
-        rtnStr = qnArr[qorder-1];
+        rtnStr = qnArr[qorder - 1];
         return rtnStr;
     }
 
-    //方差s^2=[(x1-x)^2 +...(xn-x)^2]/n 或者s^2=[(x1-x)^2 +...(xn-x)^2]/(n-1)
+    // 方差s^2=[(x1-x)^2 +...(xn-x)^2]/n 或者s^2=[(x1-x)^2 +...(xn-x)^2]/(n-1)
     public static double fc(List<Double> x) {
         if (N_Utils.isListEmpty(x)) return 0;
         int m = x.size();
         double sum = 0;
-        for (int i = 0; i < m; i++) {//求和
+        for (int i = 0; i < m; i++) {// 求和
             sum += x.get(i);
         }
-        double dAve = sum / m;//求平均值
+        double dAve = sum / m;// 求平均值
         double dVar = 0;
-        for (int i = 0; i < m; i++) {//求方差
+        for (int i = 0; i < m; i++) {// 求方差
             dVar += (x.get(i) - dAve) * (x.get(i) - dAve);
         }
         return dVar / m;
     }
 
-    //标准差σ=sqrt(s^2)
+    // 标准差σ=sqrt(s^2)
     public static double bzc(List<Double> x) {
         if (N_Utils.isListEmpty(x)) return 0;
         return N_Utils.formatDouble(Math.sqrt(fc(x)), 2);
     }
 
 
-    //中位数
-    public static double zws(List<Double> list){
+    // 中位数
+    public static double zws(List<Double> list) {
         if (N_Utils.isListEmpty(list)) return 0;
         // 先对列表进行排序
         List<Double> sorteList = list.stream().sorted().collect(Collectors.toList());
         }
     }
 
-    //区分度=2×（高分组平均分-低分组平均分）/100
+    // 区分度=2×（高分组平均分-低分组平均分）/100
     public static double qfd(List<Double> scores) {
         if (N_Utils.isListEmpty(scores)) return 0;
 
         return div(mul(2, sub(highGroupAvg, lowGroupAvg)), 100);
     }
 
-    //计算平均分
+    // 计算平均分
     public static double calculateAverage(List<Double> scores) {
         if (N_Utils.isListEmpty(scores)) return 0;
         double sum = 0.0;
         return div(sum, scores.size());
     }
 
-    //众数
-    public static List<Double> zs(List<Double> list){
+    //计算占比
+    public static double calculateRate(Object v1,Object v2){
+        BigDecimal b1 = new BigDecimal(v1.toString());
+        BigDecimal b2 = new BigDecimal(v2.toString());
+
+        BigDecimal b3 = b1.divide(b2, 4, BigDecimal.ROUND_DOWN);
+        return b3.multiply(new BigDecimal("100")).doubleValue();
+    }
+
+    // 众数
+    public static List<Double> zs(List<Double> list) {
         List<Double> modes = new ArrayList<>();
         if (N_Utils.isListEmpty(list)) return modes;
 
         // 使用HashMap来统计每个元素出现的次数
         Map<Double, Long> countMap = list.stream()
-                                            .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
+                                         .collect(Collectors.groupingBy(e -> e, Collectors.counting()));
 
         long maxCount = 0;
         // 找出最大的出现次数
         return modes;
     }
 
-    //超均率 =（个人单科得分-全校平均分）÷全校平均分
-    public static double cjl(Object v1,Object v2){
-        if(v2 == null || "0".equals(v2)) return 0;
+    // 超均率 =（个人单科得分-全校平均分）÷全校平均分
+    public static double cjl(Object v1, Object v2) {
+        if (v2 == null || "0".equals(v2)) return 0;
 
         BigDecimal b1 = new BigDecimal(v1.toString());
         BigDecimal b2 = new BigDecimal(v2.toString());
         return b1.subtract(b2).divide(b2, 2, BigDecimal.ROUND_DOWN).doubleValue();
     }
 
-    //标准分 班级标准分 =（班级得分-全校平均分）÷年级标准差
+    // 标准分 班级标准分 =（班级得分-全校平均分）÷年级标准差
     public static double bzf(Double score, Double avgscore, Double bzc) {
         double bzscore = div(sub(score, avgscore), bzc);
         return N_Utils.formatDouble(bzscore, 2);
     }
 
-    //综合率 固定计算=平均得分率*50%+优秀率*25%+及格率*25%
+    // 综合率 固定计算=平均得分率*50%+优秀率*25%+及格率*25%
     public static double zhl(Double v1, Double v2, Double v3) {
         double s1 = mul(v1, 0.5);
         double s2 = mul(v2, 0.25);
         return add(s1, add(s2, s3));
     }
 
-    //学科上线贡献率  班级学科上线贡献率=（班级学科上线率-班级总分上线率）-（学校学科的上线率-学校总分上线率）
-    public static double sxgxl(Double v1,Double v2,Double v3,Double v4){
-        double s1 = sub(v1,v2);
-        double s2 = sub(v3,v4);
-        return sub(s1,s2);
+    // 学科上线贡献率  班级学科上线贡献率=（班级学科上线率-班级总分上线率）-（学校学科的上线率-学校总分上线率）
+    public static double sxgxl(Double v1, Double v2, Double v3, Double v4) {
+        double s1 = sub(v1, v2);
+        double s2 = sub(v3, v4);
+        return sub(s1, s2);
     }
 
-    //短板学生 学科短板学生：偏科指数=（单科分值-全科平均分）÷全科标准差 ，如果偏科指数>1,标识此科为短板学科
-    public static double dbxs(Double v1,Double v2,Double v3){
-        return div(sub(v1,v2),v3);
+    // 短板学生 学科短板学生：偏科指数=（单科分值-全科平均分）÷全科标准差 ，如果偏科指数>1,标识此科为短板学科
+    public static double dbxs(Double v1, Double v2, Double v3) {
+        return div(sub(v1, v2), v3);
     }
 
-    //鉴别指数 试题鉴别指数 = 前27%的学生得分率-后27%的学生得分率
-    //将学生按总分排序（去掉缺考的学生），取前27%、后27%的学生，分别计算在该题上的得分率，两者之差即为鉴别指数
-    public static double jbzs(List<Double> list,Double qscore){
+    // 鉴别指数 试题鉴别指数 = 前27%的学生得分率-后27%的学生得分率
+    // 将学生按总分排序（去掉缺考的学生），取前27%、后27%的学生，分别计算在该题上的得分率，两者之差即为鉴别指数
+    public static double jbzs(List<Double> list, Double scoreRate) {
         List<Double> sortList = list.stream().sorted().collect(Collectors.toList());
         int size = sortList.size();
-        int count = (int)(size * 0.27);//27%学生数量
+        int count = (int) (size * 0.27);// 27%学生数量
 
         // 前27%的学生
         List<Double> topGroup = sortList.subList(0, count);
         double topScore = topGroup.stream().mapToDouble(Double::doubleValue).sum();
-        double topRate = div(topScore, mul(qscore, count));
+        double topRate = div(topScore, mul(scoreRate, count));
 
         // 后27%的学生
         List<Double> bottomGroup = sortList.subList(size - count, size);
         double bottomScore = bottomGroup.stream().mapToDouble(Double::doubleValue).sum();
-        double bottomRate = div(bottomScore, mul(qscore, count));
+        double bottomRate = div(bottomScore, mul(scoreRate, count));
 
         // 鉴别指数
         return sub(topRate, bottomRate);
     }
 
+    //排名分组计算 用于第一组(第1-10名)
+    public static List<RankGroupVo> rankGroup(Integer total) {
+        List<RankGroupVo> rtnList = new ArrayList<>();
+
+        int count = total / 10;
+        for (int i = 0; i < count; i++) {
+            RankGroupVo rg = new RankGroupVo();
+            rg.setMaxvalue((i + 1) * 10);
+            rg.setMinvalue(i * 10 + 1);
+            rtnList.add(rg);
+        }
+
+        if (total % 10 > 0) {
+            //未被整除，添加最后一组
+            RankGroupVo rg = new RankGroupVo();
+            rg.setMaxvalue(total);
+            rg.setMinvalue(count * 10 + 1);
+            rtnList.add(rg);
+        }
+        return rtnList;
+    }
+
     public static void main(String[] args) {
-        System.out.println(cjl(50,40));
+        System.out.println(cjl(50, 40));
+
     }
 
 

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportother/RankGroupVo.java

+package com.xhkjedu.smarking.vo.report.reportother;
+
+import lombok.Data;
+
+/**
+ * @Description：分段分值
+ * @Author: WN
+ * @Date: 2024/12/10 16:44:02
+ **/
+@Data
+public class RankGroupVo {
+
+    //最大值
+    private Integer maxvalue;
+
+    //最小值
+    private Integer minvalue;
+}

smarking/src/main/java/com/xhkjedu/smarking/vo/report/reportother/SzJsonVo.java

+package com.xhkjedu.smarking.vo.report.reportother;
+
+import lombok.Data;
+
+/**
+ * @Description：数值json解析对象
+ * @Author: WN
+ * @Date: 2024/12/11 10:48:19
+ **/
+@Data
+public class SzJsonVo {
+    private String djkey;//数据项key
+    private Object djvalue;//数据项值
+    private Double djscore;//数据项值对应分值
+
+    private Double maxvalue;//最大值
+    private Double minvalue;//最小值
+
+    private String calformula;//综合率-计算
+    private String custname;//综合率-名称
+    private String selname;//综合率-指标名称
+
+    private Integer alltop;//全体考生前多少名
+    private Integer allbottom;//全体考生后多少名
+    private Integer goodtype;//优秀学生类型1按名次 2按比例
+    private Integer goodvalue;//优秀学生前N名
+    private Integer badtype;//提高学生类型1按名次 2按比例
+    private Integer badvalue;//待提高学生前N名
+
+}

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

     </select>
     <!--考试报告科目列表-->
     <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
+        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}
         <if test="exammode!=3">

smarking/src/main/resources/mapper/paper/MsPaperQtypeQuestionMapper.xml

     <update id="updateQuestionCoorByMpid">
         update ms_paper_qtype_question set pagenum=0,stemcoor=null,quecoor=null where mpid=#{mpid}
     </update>
+
+    <!--试卷中所有试题-考试报告-->
+    <select id="listQuestionsForReport" resultType="com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion">
+        select q.mptqid,q.mptid,q.mpid,q.ctype,q.qtype,q.questionid,q.qtypeid,q.qtypename,q.qn,
+        q.qscore,q.qorder,q.optionnum,q.qanswer,qt.mptqn,qt.mptnum,qt.mptscore
+        from ms_paper_qtype_question q left join ms_paper_qtype qt on q.mptid=qt.mptid
+        where q.mpid=#{mpid} order by qt.mptorder,q.qorder
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportother/MsrReportparamMapper.xml

 
     <!--获取考试对应参数-->
     <select id="listReportparamByRpbelong" resultType="com.xhkjedu.smarking.model.report.reportother.MsrReportparam">
-        select * from msr_reportparam where examid=#{rp.examid}
-        <if test="rp.rpbelong!= null and rp.rpbelong!= ''">
-            and rpbelong = #{rp.rpbelong}
+        select * from msr_reportparam where examid=#{examid}
+        <if test="rpbelong!= null and rpbelong!= ''">
+            and rpbelong = #{rpbelong}
         </if>
-        <if test="rp.reportcode!= null and rp.reportcode!= ''">
-            and reportcode = #{rp.reportcode}
+        <if test="reportcode!= null and reportcode!= ''">
+            and reportcode = #{reportcode}
         </if>
         order by rpid
     </select>

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

     <!--获取考试所有参考学生作答情况-->
     <select id="listAllStuQuesByExamid" resultType="com.xhkjedu.smarking.model.stupaper.MsPaperStudentQuestion">
         select sq.mpsqid,sq.studentid,sq.subjectid,sq.mpid,sq.mpsid,sq.mptid,sq.mptqid,sq.ctype,sq.questionid,sq.qn,sq.qorder,
-        sq.qscore,sq.answered,sq.answertype,sq.stuanswer,sq.stuscore,sq.stumerge,sq.hasgood,sq.hasbad,q.qtype,q.qanswer,qt.mptqn
+        sq.qscore,sq.answered,sq.answertype,sq.stuanswer,sq.stuscore,sq.stumerge,sq.hasgood,sq.hasbad
         from ms_paper_student_question sq
         left join ms_paper_student ps on sq.mpsid=ps.mpsid
-        left join ms_paper_qtype_question q on sq.mptqid=q.mptqid
-        left join ms_paper_qtype qt on q.mptid=qt.mptid
         where sq.examid=#{examid} and ps.sstate=2 order by sq.mpid,sq.studentid
     </select>
 </mapper>