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

# Conflicts:
#	smarking/src/main/java/com/xhkjedu/smarking/utils/MarkingUtil.java

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

 package com.xhkjedu.smarking.service.report.reportother;
 
+import com.alibaba.fastjson.JSON;
 import com.xhkjedu.smarking.mapper.exam.*;
 import com.xhkjedu.smarking.mapper.report.reportother.MsrExamMapper;
+import com.xhkjedu.smarking.mapper.report.reportother.MsrReportparamMapper;
 import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentMapper;
+import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectClassMapper;
 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.reportother.MsrReportparam;
 import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubject;
+import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectClass;
 import com.xhkjedu.smarking.utils.MarkingUtil;
+import com.xhkjedu.smarking.vo.report.reportother.StuRankVo;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
 import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
 
     private MsrSubjectMapper msrSubjectMapper;
     @Resource
     private MsrStudentMapper msrStudentMapper;
+    @Resource
+    private MsrReportparamMapper msrReportparamMapper;
+    @Resource
+    private MsrSubjectClassMapper msrSubjectClassMapper;
 
     /**
      * @Description 生成报告
             student.setScorerate(N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), student.getFullscore()));
         }
 
+        //等级参数
+        List<MsrReportparam> djParams = msrReportparamMapper.listReportparamByRpbelong(examid, "subjectshow", "");
+        List<SzJsonVo> djList = new ArrayList<>();
+        if (N_Utils.isListNotEmpty(djParams)) {
+            djList = JSON.parseArray(djParams.get(0).getSzjson(), SzJsonVo.class);
+        }
+
         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(MsrStudent::getStudentid).distinct().count());
         List<MsrStudent> schoolStudents = 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<>();//班级科目学生分数排名
+        Map<String, StuRankVo> schoolStuRank = new HashMap<>();//学校学生分数排名
+        Map<String, StuRankVo> schoolSubStuRank = new HashMap<>();//学校科目学生分数排名
+        Map<String, StuRankVo> classStuRank = new HashMap<>();//班级学生分数排名
+        Map<String, StuRankVo> classSubStuRank = new HashMap<>();//班级科目学生分数排名
         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();
             String subjectid = paperStudent.getSubjectid();
             Integer studentid = paperStudent.getStudentid();
             Double stuscore = paperStudent.getStuscore();
+            Double fullscore1 = paperStudent.getFullscore();
             String key = subjectid + "_" + studentid;
             for (MsClassStudent student : sClassStudent.get(key)) {
                 MsrStudent cs = new MsrStudent();
                 cs.setStudentid(student.getStudentid());
                 cs.setSubjectid(subjectid);
                 cs.setStuscore(stuscore);
+                cs.setFullscore(fullscore1);
                 paperStudents2.add(cs);
             }
         }
                 cs.setStudentid(csEntry.getKey());
                 cs.setSubjectid(subjectid);
                 cs.setStuscore(csEntry.getValue().stream().mapToDouble(MsrStudent::getStuscore).sum());
+                cs.setFullscore(fullscore);
                 rstudents.add(cs);
             }
             bjdfMap.put(classid + "_" + subjectid, rstudents.stream().mapToDouble(MsrStudent::getStuscore).sum());
 
         //学生成绩分析
         for (MsrStudent student : classStudents) {
-            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap, djList);
         }
         for (MsrStudent student : classSubjectStudents) {
-            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap);
+            setStudent(student, classStuRank, schoolStuRank, classSubStuRank, schoolSubStuRank, bjdfMap, subjectMap, djList);
+        }
+        List<MsrStudent> msrStudents = new ArrayList<>();
+        msrStudents.addAll(classStudents);
+        msrStudents.addAll(classSubjectStudents);
+        if (N_Utils.isListNotEmpty(msrStudents)) msrStudentMapper.insertList(msrStudents);
+
+        //科目班级分数分布区间分析
+        //区间参数
+        List<MsrReportparam> qjParams = msrReportparamMapper.listReportparamByRpbelong(examid, "scoresection", "");
+        Map<String, List<SzJsonVo>> qjMap = new HashMap<>();
+        for (MsrReportparam param : qjParams) {
+            qjMap.put(param.getSubjectid(), JSON.parseArray(param.getSzjson(), SzJsonVo.class));
         }
-        if (N_Utils.isListNotEmpty(classStudents)) msrStudentMapper.insertList(classStudents);
-        if (N_Utils.isListNotEmpty(classSubjectStudents)) msrStudentMapper.insertList(classSubjectStudents);
+        List<MsrSubjectClass> msrSubjectClasses = new ArrayList<>();
+        Map<String, List<MsrStudent>> scCollect = msrStudents.stream().collect(Collectors.groupingBy(s -> s.getClassid() + "_" + s.getSubjectid()));
+        for (Map.Entry<String, List<MsrStudent>> entry : scCollect.entrySet()) {
+            String key = entry.getKey();
+            Integer classid = N_Utils.obj2Int(key.split("_")[0]);
+            subjectid = key.split("_")[1];
+            List<SzJsonVo> list = qjMap.get(subjectid);
+            List<MsrStudent> studentList = entry.getValue();
+            for (SzJsonVo vo : list) {
+                Object djvalue = vo.getDjvalue();
+                MsrSubjectClass msrSubjectClass = new MsrSubjectClass();
+                msrSubjectClass.setExamid(examid);
+                msrSubjectClass.setClassid(classid);
+                msrSubjectClass.setSubjectid(subjectid);
+                msrSubjectClass.setQjname(vo.getDjkey());
+                msrSubjectClasses.add(msrSubjectClass);
+            }
+        }
+        msrSubjectClassMapper.insertList(msrSubjectClasses);
 
         examMapper.updateExamState(examid, 3);
     }
     }
 
     //设置学生分析计算参数
-    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) {
+    private void setStudent(MsrStudent student, Map<String, StuRankVo> classStuRank, Map<String, StuRankVo> schoolStuRank
+            , Map<String, StuRankVo> classSubStuRank, Map<String, StuRankVo> schoolSubStuRank
+            , Map<String, Double> bjdfMap, Map<String, MsrSubject> subjectMap, List<SzJsonVo> djList) {
         String subjectid;
         Integer classid = student.getClassid();
         Integer studentid = student.getStudentid();
         MsrSubject msrSubject = subjectMap.get(subjectid);
         Double pjf = msrSubject.getAvgscore();//年级平均分
         student.setBzf(MarkingUtil.bzf(bjdfMap.get(classid + "_" + subjectid), pjf, msrSubject.getBzc()));
-        Integer classrank;
-        Integer schoolrank;
+        StuRankVo classRankVo;
+        StuRankVo schoolRankVo;
         if (subjectid.equals("zf")) {
-            classrank = classStuRank.get(classid + "_" + studentid);
-            schoolrank = schoolStuRank.get(studentid.toString());
+            classRankVo = classStuRank.get(classid + "_" + studentid);
+            schoolRankVo = schoolStuRank.get(studentid.toString());
         } else {
-            classrank = classSubStuRank.get(classid + "_" + subjectid + "_" + studentid);
-            schoolrank = schoolSubStuRank.get(subjectid + "_" + studentid);
+            classRankVo = classSubStuRank.get(classid + "_" + subjectid + "_" + studentid);
+            schoolRankVo = schoolSubStuRank.get(subjectid + "_" + studentid);
         }
+        Integer classrank = classRankVo.getRank();
+        Integer schoolrank = schoolRankVo.getRank();
         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));//学科强弱值 = 平均成绩排名率- 个人成绩排名率
+        double dfv = N_Utils.getDoubleDivideAndMulitiply(student.getStuscore(), msrSubject.getFullscore());
+        student.setGradevalue(MarkingUtil.dj(dfv, djList));
+        student.setHighschool(N_Utils.getIntegerDivideAndMulitiply(schoolrank, schoolRankVo.getNum2()));
     }
 
     //分数排名
-    private void setRank(List<MsrStudent> students, Map<String, Integer> rank, Integer code) {
+    private void setRank(List<MsrStudent> students, Map<String, StuRankVo> rank, Integer code) {
         List<Map.Entry<Double, List<MsrStudent>>> gslist2 = students.stream()
                                                                     .collect(Collectors.groupingBy(MsrStudent::getStuscore)).entrySet()
                                                                     .stream().sorted((s1, s2) -> -Double.compare(s1.getKey(), s2.getKey())).collect(Collectors.toList());
         int index = 1;
+        StuRankVo rankVo;
         String key;
+        List<StuRankVo> rankVos = new ArrayList<>();
         for (Map.Entry<Double, List<MsrStudent>> entry : gslist2) {
+            int num = entry.getValue().size();
             for (MsrStudent cgs : entry.getValue()) {
                 Integer studentid = cgs.getStudentid();
                 Integer classid = cgs.getClassid();
                 } else {//班级科目学生
                     key = classid + "_" + subjectid + "_" + studentid;
                 }
-                rank.put(key, index);
+                rankVo = new StuRankVo();
+                rankVo.setKey(key);
+                rankVo.setRank(index);
+                rankVo.setNum(num);
+                rankVos.add(rankVo);
+                rank.put(key, rankVo);
             }
-            index = index + entry.getValue().size();
+            index = index + num;
+        }
+        List<Integer> codes = Arrays.asList(1, 2);//计算超过当前排名人数
+        if (!codes.contains(code)) return;
+        for (StuRankVo vo : rankVos) {
+            Integer rank1 = vo.getRank();
+            int sum = rankVos.stream().filter(r -> rank1.compareTo(r.getRank()) < 0).mapToInt(StuRankVo::getNum).sum();
+            vo.setNum2(sum);
         }
     }
 }

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

 import com.xhkjedu.smarking.config.ConfigKey;
 import com.xhkjedu.smarking.vo.paper.PaperFileVo;
 import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
+import com.xhkjedu.smarking.vo.report.reportother.SzJsonVo;
 import com.xhkjedu.utils.N_Utils;
 import com.xhkjedu.vo.ResultVo;
 import lombok.extern.slf4j.Slf4j;
         return rtnList;
     }
 
+    //object转double
+    public static double objToDouble(Object v1) {
+        if (N_Utils.isEmpty(v1)) return 0.0;
+        return Double.parseDouble(v1.toString());
+    }
+
+    //等级
+    public static String dj(Double dfv, List<SzJsonVo> djList) {
+        for (SzJsonVo vo : djList) {
+            if (dfv.compareTo(objToDouble(vo.getDjvalue())) >= 0) {
+                return vo.getDjkey();
+            }
+        }
+        return "";
+    }
     public static void main(String[] args) {
         List<int[]> rtnList = fdScore(84.0, 5);
         for (int[] rtn : rtnList) {
             System.out.println(rtn[0] + "-" + rtn[1]);
         }
     }
-
 }

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

+package com.xhkjedu.smarking.vo.report.reportother;
+
+import lombok.Data;
+
+/**
+ * @Description
+ * @Author ywx
+ * Date 2024/12/11 17:37
+ **/
+@Data
+public class StuRankVo {
+    private String key;//排名key
+    private Integer rank;//排名
+    private Integer num;//排名人数
+    private Integer num2;//超过当前排名人数
+}