学科素养

smarking/src/main/java/com/xhkjedu/smarking/controller/report/XksyReportController.java

@@ -22,6 +22,19 @@ public class XksyReportController {
     @Resource
     private MsrSubjectPointService msrSubjectPointService;
 
+    /*
+     * @Description 标定知识点-试题知识点
+     * @Date 2025/1/2 16:34:45
+     * @Author WN
+     * @Param [params]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/zsd")
+    public ResultVo listXksyQuestionPoints(@RequestBody ExamReportParams params){
+        N_Utils.validation(new Object[]{params.getExamid(),"考试id",1,params.getSubjectid(),"科目id",2});
+        return new ResultVo(0,"获取成功",msrSubjectPointService.listXksyQuestionPoints(params));
+    }
+
     /*
      * @Description 知识点整体分析
      * @Date 2024/12/31 16:46:51
@@ -29,9 +42,35 @@ public class XksyReportController {
      * @Param [params]
      * @Return com.xhkjedu.vo.ResultVo
      **/
-    @PostMapping("/zstzt")
+    @PostMapping("/zsd_zt")
     public ResultVo listXksyPointZt(@RequestBody ExamReportParams params){
         N_Utils.validation(new Object[]{params.getExamid(),"考试id",1,params.getSubjectid(),"科目id",2,params.getPointlevel(),"知识点层级",1});
         return new ResultVo(0,"获取成功",msrSubjectPointService.listXksyPointZt(params));
     }
+
+    /*
+     * @Description 单个知识点分析-所有知识点
+     * @Date 2025/1/2 9:18:13
+     * @Author WN
+     * @Param [params]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/zsd_one_all")
+    public ResultVo listXksyPointOneForPoints(@RequestBody ExamReportParams params){
+        N_Utils.validation(new Object[]{params.getExamid(),"考试id",1,params.getSubjectid(),"科目id",2});
+        return new ResultVo(0,"获取成功",msrSubjectPointService.listXksyPointOneForPoints(params));
+    }
+
+    /*
+     * @Description 单个知识点分析-详细分析
+     * @Date 2025/1/2 15:36:20
+     * @Author WN
+     * @Param [params]
+     * @Return com.xhkjedu.vo.ResultVo
+     **/
+    @PostMapping("/zsd_one_xq")
+    public ResultVo listXksyPointOneForPointDetail(@RequestBody ExamReportParams params){
+        N_Utils.validation(new Object[]{params.getExamid(),"考试id",1,params.getSubjectid(),"科目id",2, params.getPointlevel(),"知识点级别",1,params.getPointid(),"知识点id",1});
+        return new ResultVo(0,"获取成功",msrSubjectPointService.listXksyPointOneForPointDetail(params));
+    }
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportclass/MsrClassQuestionMapper.java

@@ -38,4 +38,6 @@ public interface MsrClassQuestionMapper extends TkMapper<MsrClassQuestion> {
     List<Map<String,Object>> listQuestionsFroMtzlSt(@Param("param") ExamReportParams param);
     //命题质量-试题分析-单试题常用分析指标
     Map<String,Object> listQuestionByMptqidForMtzlSt(@Param("param") ExamReportParams param);
+    //学科素养-单个知识点分析-知识点下试题
+    List<Map<String,Object>> listQuestionsForXksyOnePoint(@Param("param") ExamReportParams param);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectPointMapper.java

@@ -7,6 +7,7 @@ import com.xhkjedu.smarking.vo.report.reportsubject.PointVo;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 阅卷报告-学科知识点表 Mapper 接口
@@ -17,7 +18,18 @@ public interface MsrSubjectPointMapper extends TkMapper<MsrSubjectPoint> {
 
     //科目知识点
     List<PointVo> listSubjectPoints(@Param("subjectid") String subjectid, @Param("examid") Integer examid);
+    //学科素养-标定知识点-试题知识点
+    List<Map<String,Object>> listQuestionPointsForXhsy(@Param("param")ExamReportParams param);
 
     //学科素养-知识点整体分析-级别下知识点
     List<MsrSubjectPoint> listXksyPointsZt(@Param("param")ExamReportParams param);
+    //学科素养-单个知识点分析-所有知识点
+    List<Map<String,Object>> listXksyPointsAll(@Param("param")ExamReportParams param);
+    //学科素养-单个知识点分析-知识点详情
+    MsrSubjectPoint getXksyPointByPointid(@Param("param")ExamReportParams param);
+    //学科素养-单个知识点分析-各班知识点对比
+    List<Map<String,Object>> listXksyPointsForAllClass(@Param("param")ExamReportParams param);
+
+    //删除知识点相关报告
+    void deletePointAnalyze(@Param("examid") Integer examid,@Param("subjectid") String subjectid);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectPointRankgroupMapper.java

@@ -2,6 +2,11 @@ package com.xhkjedu.smarking.mapper.report.reportsubject;
 
 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointRankgroup;
+import com.xhkjedu.smarking.vo.report.reportother.ExamReportParams;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 阅卷报告-学科知识点分段区间表 Mapper 接口
@@ -9,4 +14,7 @@ import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointRankgroup;
  * @Date 2024-12-09
  */
 public interface MsrSubjectPointRankgroupMapper extends TkMapper<MsrSubjectPointRankgroup> {
+
+    //学科素养-单个知识点分析-知识点考试分组分析
+    List<Map<String,Object>> listXksyPointOneRankgroup(@Param("param")ExamReportParams param);
 }

smarking/src/main/java/com/xhkjedu/smarking/mapper/report/reportsubject/MsrSubjectPointSectionMapper.java

@@ -2,6 +2,11 @@ package com.xhkjedu.smarking.mapper.report.reportsubject;
 
 import com.xhkjedu.base.TkMapper;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointSection;
+import com.xhkjedu.smarking.vo.report.reportother.ExamReportParams;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * @Description 阅卷报告-学科知识点分段区间表 Mapper 接口
@@ -9,4 +14,7 @@ import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointSection;
  * @Date 2024-12-09
  */
 public interface MsrSubjectPointSectionMapper extends TkMapper<MsrSubjectPointSection> {
+
+    //学科素养-单个知识点分析-知识点与总分的相关性曲线
+    List<Map<String, Object>> listXhsySections(@Param("param")ExamReportParams param);
 }

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

@@ -55,4 +55,13 @@ public class MsrSubjectPoint extends BaseBean {
     private String mptqids;
     //对应题目
     private String qns;
+
+    //满分人数
+    private Integer mfnum;
+    //满分人ids
+    private String mfids;
+    //零分人数
+    private Integer lfnum;
+    //零分人ids
+    private String lfids;
 }

smarking/src/main/java/com/xhkjedu/smarking/service/paper/MsPaperAnalyzeService.java

@@ -0,0 +1,678 @@
+package com.xhkjedu.smarking.service.paper;
+
+import com.alibaba.fastjson.JSON;
+import com.xhkjedu.smarking.mapper.paper.MsPaperAnalyzeMapper;
+import com.xhkjedu.smarking.mapper.paper.MsPaperQtypeMapper;
+import com.xhkjedu.smarking.mapper.paper.MsPaperQtypeQuestionMapper;
+import com.xhkjedu.smarking.mapper.paper.MsPaperQtypeQuestionPointMapper;
+import com.xhkjedu.smarking.model.paper.MsPaper;
+import com.xhkjedu.smarking.model.paper.MsPaperAnalyze;
+import com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion;
+import com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestionPoint;
+import com.xhkjedu.smarking.vo.paper.*;
+import com.xhkjedu.utils.N_Utils;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @Description：试卷分析
+ * @Author: WN
+ * @Date: 2025/1/2 17:01:04
+ **/
+@Service
+public class MsPaperAnalyzeService {
+    @Resource
+    private MsPaperQtypeMapper msPaperQtypeMapper;
+    @Resource
+    private MsPaperQtypeQuestionMapper msPaperQtypeQuestionMapper;
+    @Resource
+    private MsPaperQtypeQuestionPointMapper msPaperQtypeQuestionPointMapper;
+    @Resource
+    private MsPaperAnalyzeMapper msPaperAnalyzeMapper;
+
+    // 保存试卷分析--题库
+    public void savePaperAnalyzeForQuestion(MsPaper paper) {
+        Integer mpid = paper.getMpid();
+
+        // 总体分析（主观题、客观题）
+        List<MsPaperQtypeVo> qtypelist = msPaperQtypeMapper.listPaperQtypeQuestions(paper.getMpid());// 试卷题型试题信息
+        List<MsPaperQtypeQuestion> uplist = new ArrayList<>();// 改试卷中客观题选项数量
+        List<MsPaperQtypeQuestion> upComplexitylist = new ArrayList<>();// 改试卷中客观题难易度
+        List<MsPaperQtypeQuestionPoint> upQpointlist = new ArrayList<>();// 保存试卷中试题知识点关联关系
+
+        List<QuestionOrderVo> pointqlist = new ArrayList<>();// 用于存放知识点，以及知识点下得分
+        List<MsPaperQtypeQuestionVo> mquestions = new ArrayList<>();// 存放单题和母题
+        List<QuestionOrderVo> complexitylist = new ArrayList<>();// 试题难易度存放试题
+        List<QuestionPointVo> quesplist = new ArrayList<>();// 单题、母题对应知识点
+
+        // 处理出试卷中所有试题、知识点
+        List<Map<String, Object>> typelist = new ArrayList<>();// 题型分析
+        for (MsPaperQtypeVo qt : qtypelist) {
+            List<Integer> qorderlist = new ArrayList<>();
+            List<QuestionOrderVo> qtypeqlist = new ArrayList<>();
+            List<MsPaperQtypeQuestionVo> tqlist = qt.getQuestions();
+            int hasmt = 0;
+            for (MsPaperQtypeQuestionVo q : tqlist) {
+                int ctype = q.getCtype();
+                // 单题的pid设置为默认值，方便后续进行单题和母题处理
+                if (q.getQlevel() == 1) {
+                    q.setQuestionpid("000");
+                    // 判断试题是否是客观题
+                    if (N_Utils.isObjectiveQuestion(ctype)) {
+                        // 判断试题是否是客观题,暂时用mctype进行标识
+                        q.setMctype(111);
+                    } else {
+                        q.setMctype(112);
+                    }
+                    // 设置知识点
+                    mquestions.add(q);
+                    // 获取试题知识点
+                    List<Map<String, Object>> qpoints = q.getPoints();
+                    // 处理试题知识点占分
+                    setPaperQuestionPointScore(pointqlist, quesplist, qpoints, q, null, null);
+                    setPaperQuestionPointRelation(qpoints, q, null, upQpointlist, mpid);
+                    setPaperQuestionQtypeScore(qtypeqlist, q, null, null);// 处理试题题型
+                    setPaperQuestionComplexityScore(complexitylist, q, null, null, upComplexitylist);// 处理试题难易度
+
+                }
+                if (q.getQlevel() == 3) {
+                    hasmt++;
+                }
+                if (!qorderlist.contains(q.getQorder())) {
+                    qorderlist.add(q.getQorder());
+                }
+                // 为了处理客观题中选项数量
+                if (ctype == 1 || ctype == 2 || ctype == 4 || ctype == 5 || ctype == 6) {
+                    List<String> strlst = JSON.parseArray(q.getQoption(), String.class);
+                    MsPaperQtypeQuestion eqq = new MsPaperQtypeQuestion();
+                    eqq.setMptqid(q.getMptqid());
+                    eqq.setOptionnum(strlst.size());
+                    uplist.add(eqq);
+                }
+            }
+
+            if (hasmt > 0) {
+                // 说明该题型下有复合题,复合体进行知识点、题型下试题题号及id进行操作
+                LinkedHashMap<String, List<MsPaperQtypeQuestionVo>> quesMap = tqlist.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestionVo::getQuestionpid,
+                                                                                                                            LinkedHashMap::new, Collectors.toList()));
+                for (Map.Entry<String, List<MsPaperQtypeQuestionVo>> entry : quesMap.entrySet()) {
+                    if (!entry.getKey().equals("000")) {
+                        // 说明该题为母题，
+                        MsPaperQtypeQuestionVo mq = new MsPaperQtypeQuestionVo();
+                        List<MsPaperQtypeQuestionVo> sonques = entry.getValue();
+                        int k = 0;// 如果k大于1说明有小题是主观题，则母题为主观题
+                        double score = 0;
+                        for (MsPaperQtypeQuestionVo sq : sonques) {
+                            if (!N_Utils.isObjectiveQuestion(sq.getCtype())) {
+                                k++;
+                            }
+                            score = N_Utils.getDoubleSum(score, sq.getQscore());
+                        }
+
+                        MsPaperQtypeQuestionVo qobj = sonques.get(0);
+                        mq.setQuestionid(qobj.getQuestionpid());
+                        mq.setComplexity(qobj.getMcomplexity());
+                        mq.setQorder(qobj.getQorder());
+                        mq.setQscore(score);
+                        mq.setQtypename(qobj.getMqtypename());
+                        if (k == 0) {
+                            mq.setMctype(111);
+                        } else {
+                            mq.setMctype(112);
+                        }
+                        mq.setQlevel(qobj.getMqlevel());
+                        mq.setSonques(sonques);
+                        // 获取所有子题的试题题号
+                        String[] qnstr = sonques.stream().map(MsPaperQtypeQuestionVo::getQn).toArray(String[]::new);
+                        // 所有子题的试题eptqid
+                        List<Integer> eptqids = sonques.stream().map(MsPaperQtypeQuestionVo::getMptqid).collect(Collectors.toList());
+                        Integer[] eptqidstr = eptqids.toArray(new Integer[0]);
+
+                        // 获取知识点
+                        List<Map<String, Object>> qpoints = sonques.get(0).getPoints();
+                        mq.setPoints(qpoints);
+                        mquestions.add(mq);
+                        setPaperQuestionPointScore(pointqlist, quesplist, qpoints, mq, qnstr, eptqids);
+                        setPaperQuestionPointRelation(qpoints, mq, eptqids, upQpointlist, mpid);
+                        setPaperQuestionQtypeScore(qtypeqlist, mq, qnstr, eptqidstr);// 处理试题题型
+                        setPaperQuestionComplexityScore(complexitylist, mq, qnstr, eptqidstr, upComplexitylist);// 处理试题难易度
+                    }
+                }
+            }
+
+            // 试题题型分析数据
+            double storerate = N_Utils.getDoubleDivideAndMulitiply(qt.getMptscore(), paper.getPscore());
+            Map<String, Object> tmap = new TreeMap<>();
+            tmap.put("qtid", qt.getMptid());
+            tmap.put("qtname", qt.getMptname());
+            tmap.put("num", qt.getMptnum());
+            tmap.put("score", qt.getMptscore());
+            tmap.put("srate", storerate);
+            qtypeqlist = qtypeqlist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList());
+            tmap.put("ques", qtypeqlist);
+            typelist.add(tmap);
+        }
+
+        // 进行客观题选项处理
+        if (N_Utils.isListNotEmpty(uplist)) {
+            msPaperQtypeQuestionMapper.updateBatchQuestionOptionnum(uplist);
+        }
+
+        // 试题总体分布进行分析
+        // 客观题集合
+        List<MsPaperQtypeQuestionVo> ktlst = mquestions.stream().filter(q -> q.getMctype() == 111).collect(Collectors.toList());
+        int ktnum = ktlst.size();
+        double ktscore = ktlst.stream().mapToDouble(MsPaperQtypeQuestionVo::getQscore).sum();
+        double ktnrate = N_Utils.getIntegerDivideAndMulitiply(ktnum, paper.getPnum());
+        double ktsrate = N_Utils.getDoubleDivideAndMulitiply(ktscore, paper.getPscore());
+        List<MsPaperQsVo> ranglist = new ArrayList<>();
+        ranglist.add(new MsPaperQsVo("客观题", ktscore, ktnum, ktsrate, ktnrate));
+        MsPaperQsVo zgq = new MsPaperQsVo();
+        zgq.setQtname("主观题");
+        zgq.setNum(paper.getPnum() - ktnum);
+        zgq.setNrate(N_Utils.getDoubleReduce(100.0, ktnrate));
+        zgq.setScore(N_Utils.getDoubleReduce(paper.getPscore(), ktscore));
+        zgq.setSrate(N_Utils.getDoubleReduce(100.0, ktsrate));
+        ranglist.add(zgq);
+        Map<String, Object> ztmap = new TreeMap<>();
+        ztmap.put("pnum", paper.getPnum());
+        ztmap.put("pscore", paper.getPscore());
+        ztmap.put("ranglist", ranglist);
+
+        // 设置试卷中试题难易度
+        msPaperQtypeQuestionMapper.updateBatchQuestionComplexity(upComplexitylist);
+
+        // 难易度
+        List<Map<String, Object>> clist = new ArrayList<>();
+        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(QuestionOrderVo::getScore).sum();
+                score = N_Utils.formatDouble(score, 1);
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
+                Map<String, Object> prate = new TreeMap<>();
+                prate.put("level", Integer.parseInt(entry.getKey()));
+                prate.put("score", score);
+                prate.put("srate", srate);
+                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
+                clist.add(prate);
+            }
+        }
+
+        // 保存试卷试题知识点关系
+        msPaperQtypeQuestionPointMapper.deleteByMpid(mpid);
+        msPaperQtypeQuestionPointMapper.insertList(upQpointlist);
+
+        // 知识点分析
+        List<Map<String, Object>> pointlist = new ArrayList<>();
+        if (N_Utils.isListNotEmpty(pointqlist)) {
+            LinkedHashMap<String, List<QuestionOrderVo>> pointmap = pointqlist.stream().collect(Collectors.groupingBy(QuestionOrderVo::getId, LinkedHashMap::new,
+                                                                                                                      Collectors.toList()));
+            // 根据指示进行分组，
+            for (Map.Entry<String, List<QuestionOrderVo>> entry : pointmap.entrySet()) {
+                List<QuestionOrderVo> pgblist = entry.getValue();
+                // 获取知识点的总分
+                Double score = pgblist.stream().mapToDouble(QuestionOrderVo::getScore).sum();
+                score = N_Utils.formatDouble(score, 1);
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
+                Map<String, Object> prate = new LinkedHashMap<>();
+                prate.put("pointid", entry.getKey());
+                prate.put("pointname", pgblist.get(0).getName());
+                prate.put("score", score);
+                prate.put("srate", srate);
+                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
+                pointlist.add(prate);
+            }
+        }
+
+        MsPaperAnalyze epa = new MsPaperAnalyze();
+        epa.setMpid(paper.getMpid());
+        epa.setAlljson(JSON.toJSONString(ztmap));// 总体分析
+        epa.setQnumjson(JSON.toJSONString(typelist));// 试题栏题型分析
+        epa.setComplexityjson(JSON.toJSONString(clist));// 难易度分析
+        epa.setPointjson(JSON.toJSONString(pointlist));// 知识点分析
+        epa.setQuespointjson(JSON.toJSONString(quesplist));
+
+        // 判断试卷你是否有分析，如果没有直接保存
+        MsPaperAnalyze existEpa = msPaperAnalyzeMapper.getObjByMpId(paper.getMpid());
+        if (existEpa == null || !N_Utils.isTrueInteger(existEpa.getMpaid())) {
+            msPaperAnalyzeMapper.insertUseGeneratedKeys(epa);
+        } else {
+            epa.setMpaid(existEpa.getMpaid());
+            msPaperAnalyzeMapper.updateByPrimaryKey(epa);
+        }
+    }
+
+    // 设置知识点
+    private void setPaperQuestionPointScore(List<QuestionOrderVo> pointqlist, List<QuestionPointVo> quesplist, List<Map<String, Object>> qpoints, MsPaperQtypeQuestionVo dq,
+                                            String[] qnstr, List<Integer> mptqids) {
+        if (N_Utils.isListNotEmpty(qpoints)) {
+            if (qpoints.size() == 1) {
+                // 试题只有一个知识点
+                Map<String, Object> pointmap = qpoints.get(0);
+                QuestionOrderVo qpoint = new QuestionOrderVo();
+                qpoint.setId(pointmap.get("pointid").toString());
+                qpoint.setName(pointmap.get("pointname").toString());
+                qpoint.setOrder(dq.getQorder());
+                qpoint.setScore(dq.getQscore());
+                qpoint.setQlevel(dq.getQlevel());
+                qpoint.setQuestionid(dq.getQuestionid());
+                if (qnstr == null) {
+                    qpoint.setQns(new String[]{dq.getQn()});
+                } else {
+                    qpoint.setQns(qnstr);
+                }
+
+                if (N_Utils.isListEmpty(mptqids)) {
+                    qpoint.setMptqids(new Integer[]{dq.getMptqid()});
+                } else {
+                    Integer[] mptqidstr = mptqids.toArray(new Integer[0]);
+                    qpoint.setMptqids(mptqidstr);
+                }
+                pointqlist.add(qpoint);
+
+                // 试题对应知识点
+                QuestionPointVo questionPointVo = new QuestionPointVo();
+                questionPointVo.setOrder(dq.getQorder());
+                questionPointVo.setScore(dq.getQscore());
+                questionPointVo.setQlevel(dq.getQlevel());
+                questionPointVo.setQuestionid(dq.getQuestionid());
+                List<Map<String, Object>> pointids = new ArrayList<>();
+                Map<String, Object> map = new HashMap<>();
+                map.put("pointid", pointmap.get("pointid").toString());
+                map.put("score", dq.getQscore());
+                pointids.add(map);
+                questionPointVo.setPointids(pointids);
+
+                if (N_Utils.isListEmpty(mptqids)) {
+                    List<Integer> saveids = new ArrayList<>();
+                    saveids.add(dq.getMptqid());
+                    questionPointVo.setMptqids(saveids);
+                    questionPointVo.setMptqid(dq.getMptqid());
+                } else {
+                    questionPointVo.setMptqids(mptqids);
+                    questionPointVo.setMptqid(0);
+                }
+                quesplist.add(questionPointVo);
+            } else {
+
+                // 试题有多个知识点
+                // 计算每个知识点所占分值（平均分配）
+                Double[] avgps = N_Utils.getPointAvgScore(qpoints.size(), dq.getQscore());
+                List<Map<String, Object>> pointids = new ArrayList<>();
+                for (int m = 0; m < qpoints.size(); m++) {
+                    Map<String, Object> pointmap = qpoints.get(m);
+                    QuestionOrderVo qpoint = new QuestionOrderVo();
+                    qpoint.setId(pointmap.get("pointid").toString());
+                    qpoint.setName(pointmap.get("pointname").toString());
+                    qpoint.setOrder(dq.getQorder());
+                    qpoint.setQlevel(dq.getQlevel());
+                    qpoint.setQuestionid(dq.getQuestionid());
+
+
+                    Map<String, Object> quesmap = new HashMap<>();// 试题对应知识点
+                    quesmap.put("pointid", pointmap.get("pointid").toString());
+
+                    if (avgps.length == 2 && (m + 1) == qpoints.size()) {
+                        // 不能整除分，并且是最后一个知识点
+                        qpoint.setScore(avgps[1]);
+                        quesmap.put("score", avgps[1]);
+                    } else {
+                        qpoint.setScore(avgps[0]);
+                        quesmap.put("score", avgps[0]);
+                    }
+                    pointids.add(quesmap);
+
+                    // 题号集合
+                    if (qnstr == null) {
+                        qpoint.setQns(new String[]{dq.getQn()});
+                    } else {
+                        qpoint.setQns(qnstr);
+                    }
+                    // 试卷中试题id集合
+                    if (N_Utils.isListEmpty(mptqids)) {
+                        qpoint.setMptqids(new Integer[]{dq.getMptqid()});
+                    } else {
+                        Integer[] eptqidstr = mptqids.toArray(new Integer[0]);
+                        qpoint.setMptqids(eptqidstr);
+                    }
+                    pointqlist.add(qpoint);
+                }
+
+                // 试题对应知识点
+                QuestionPointVo questionPointVo = new QuestionPointVo();
+                questionPointVo.setOrder(dq.getQorder());
+                questionPointVo.setScore(dq.getQscore());
+                questionPointVo.setQlevel(dq.getQlevel());
+                questionPointVo.setQuestionid(dq.getQuestionid());
+                questionPointVo.setPointids(pointids);
+                if (N_Utils.isListEmpty(mptqids)) {
+                    List<Integer> saveids = new ArrayList<>();
+                    saveids.add(dq.getMptqid());
+                    questionPointVo.setMptqids(saveids);
+                    questionPointVo.setMptqid(dq.getMptqid());
+
+                } else {
+                    questionPointVo.setMptqids(mptqids);
+                    questionPointVo.setMptqid(0);
+                }
+                quesplist.add(questionPointVo);
+
+            }
+
+        } else {
+            QuestionPointVo questionPointVo = new QuestionPointVo();
+            questionPointVo.setOrder(dq.getQorder());
+            questionPointVo.setScore(dq.getQscore());
+            questionPointVo.setQlevel(dq.getQlevel());
+            questionPointVo.setQuestionid(dq.getQuestionid());
+            questionPointVo.setPointids(null);
+            if (N_Utils.isListEmpty(mptqids)) {
+                List<Integer> saveids = new ArrayList<>();
+                saveids.add(dq.getMptqid());
+                questionPointVo.setMptqids(saveids);
+                questionPointVo.setMptqid(dq.getMptqid());
+            } else {
+                questionPointVo.setMptqids(mptqids);
+                questionPointVo.setMptqid(0);
+            }
+
+            quesplist.add(questionPointVo);
+        }
+    }
+
+    // 设置知识点--试卷试题知识点关联关系
+    private void setPaperQuestionPointRelation(List<Map<String, Object>> qpoints, MsPaperQtypeQuestionVo dq, List<Integer> mptqids, List<MsPaperQtypeQuestionPoint> upQpointlist,
+                                               Integer mpid) {
+        if (N_Utils.isListNotEmpty(qpoints)) {
+            // 试题对应知识点关系
+            int i = 0;
+            for (Map<String, Object> pointmap : qpoints) {
+                String pointid = pointmap.get("pointid").toString();
+                String pointname = pointmap.get("pointname").toString();
+
+                if (N_Utils.isListEmpty(mptqids)) {
+                    MsPaperQtypeQuestionPoint upPoint = new MsPaperQtypeQuestionPoint();
+                    upPoint.setMpid(mpid);
+                    upPoint.setMptqid(dq.getMptqid());
+                    upPoint.setPointid(pointid);
+                    upPoint.setPointname(pointname);
+                    upPoint.setMporder(i++);
+
+                    upQpointlist.add(upPoint);
+                } else {
+                    for (Integer mptqid : mptqids) {
+                        MsPaperQtypeQuestionPoint upPoint = new MsPaperQtypeQuestionPoint();
+                        upPoint.setMpid(mpid);
+                        upPoint.setMptqid(mptqid);
+                        upPoint.setPointid(pointid);
+                        upPoint.setPointname(pointname);
+                        upPoint.setMporder(i++);
+
+                        upQpointlist.add(upPoint);
+                    }
+                }
+            }
+        }
+
+    }
+
+    // 设置题型下试题题号及分值
+    private void setPaperQuestionQtypeScore(List<QuestionOrderVo> qtypelist, MsPaperQtypeQuestionVo dq, String[] qnstr, Integer[] mptqidstr) {
+        QuestionOrderVo qtype = new QuestionOrderVo();
+        qtype.setId(dq.getQtypeid());
+        qtype.setName(dq.getQtypename());
+        qtype.setComplexity(dq.getComplexity());
+        qtype.setOrder(dq.getQorder());
+        qtype.setScore(dq.getQscore());
+        qtype.setQlevel(dq.getQlevel());
+        qtype.setQuestionid(dq.getQuestionid());
+        if (qnstr == null) {
+            qtype.setQns(new String[]{dq.getQn()});
+        } else {
+            qtype.setQns(qnstr);
+        }
+        if (mptqidstr == null) {
+            qtype.setMptqids(new Integer[]{dq.getMptqid()});
+        } else {
+            qtype.setMptqids(mptqidstr);
+        }
+
+        qtypelist.add(qtype);
+    }
+
+    // 设置试题难易度
+    private void setPaperQuestionComplexityScore(List<QuestionOrderVo> complexityList, MsPaperQtypeQuestionVo dq, String[] qnstr, Integer[] mptqidstr,
+                                                 List<MsPaperQtypeQuestion> upComplexitylist) {
+        QuestionOrderVo qtype = new QuestionOrderVo();
+        qtype.setId(dq.getComplexity().toString());// 存放试题难易度
+        qtype.setOrder(dq.getQorder());
+        qtype.setScore(dq.getQscore());
+        qtype.setQlevel(dq.getQlevel());
+        qtype.setQuestionid(dq.getQuestionid());
+        if (qnstr == null) {
+            qtype.setQns(new String[]{dq.getQn()});
+        } else {
+            qtype.setQns(qnstr);
+        }
+
+        if (mptqidstr == null) {
+            qtype.setMptqids(new Integer[]{dq.getMptqid()});
+        } else {
+            qtype.setMptqids(mptqidstr);
+        }
+
+        complexityList.add(qtype);
+        // 设置试题难易度
+        if (mptqidstr == null) {
+            MsPaperQtypeQuestion upComplexity = new MsPaperQtypeQuestion();
+            upComplexity.setMptqid(dq.getMptqid());
+            upComplexity.setComplexity(dq.getComplexity());
+
+            upComplexitylist.add(upComplexity);
+        } else {
+            for (Integer mptqid : mptqidstr) {
+                MsPaperQtypeQuestion upComplexity = new MsPaperQtypeQuestion();
+                upComplexity.setMptqid(mptqid);
+                upComplexity.setComplexity(dq.getComplexity());
+
+                upComplexitylist.add(upComplexity);
+            }
+        }
+
+
+    }
+
+    // 保存试卷分析--附件
+    public void savePaperAnalyzeForFj(MsPaper paper) {
+        List<MsPaperQtypeVo> fjtypelist = msPaperQtypeMapper.listPaperQtypeQuesitonsForFj(paper.getMpid());
+        List<MsPaperQtypeQuestionVo> queslist = new ArrayList<>();
+        for (MsPaperQtypeVo fj : fjtypelist) {
+            List<MsPaperQtypeQuestionVo> qlist = fj.getQuestions();
+            queslist.addAll(qlist);
+        }
+
+        List<QuestionOrderVo> pointqlist = new ArrayList<>();// 用于存放知识点，以及知识点下得分
+        List<QuestionPointVo> quesplist = new ArrayList<>();// 单题对应知识点
+
+        // 总体分析（主观题、客观题）
+        // 处理题型1单选题2多选题3主观题4判断对错5判断√×6判断TF11综合题12听力13填空题
+        int znum = 0;
+        double zscore = 0;
+        int knum = 0;
+        double kscore = 0;
+        for (MsPaperQtypeQuestionVo q : queslist) {
+            if (N_Utils.isObjectiveQuestion(q.getCtype())) {
+                knum++;
+                kscore = kscore + q.getQscore();
+            } else {
+                znum++;
+                zscore = zscore + q.getQscore();
+            }
+
+            List<Map<String, Object>> qpoints = q.getPoints();
+            if(qpoints != null) {
+                // 存放知识点
+                setPaperQuestionPointScore(pointqlist, quesplist, qpoints, q, null, null);
+            }
+        }
+
+        double znumrate = N_Utils.getIntegerDivideAndMulitiply(znum, paper.getPnum());
+        double knumrate = N_Utils.getDoubleReduce(100.0, znumrate);
+
+        double zscorerate = N_Utils.getDoubleDivideAndMulitiply(zscore, paper.getPscore());
+        double kscorerate = N_Utils.getDoubleReduce(100.0, zscorerate);
+
+        List<Map<String, Object>> ranglist = new ArrayList<>();
+        Map<String, Object> zgmap = new TreeMap<>();
+        zgmap.put("qtname", "主观题");
+        zgmap.put("score", zscore);
+        zgmap.put("num", znum);
+        zgmap.put("srate", zscorerate);
+        zgmap.put("nrate", znumrate);
+        ranglist.add(zgmap);
+        Map<String, Object> kgmap = new TreeMap<>();
+        kgmap.put("qtname", "客观题");
+        kgmap.put("score", kscore);
+        kgmap.put("num", knum);
+        kgmap.put("srate", kscorerate);
+        kgmap.put("nrate", knumrate);
+        ranglist.add(kgmap);
+
+        Map<String, Object> ztmap = new TreeMap<>();
+        ztmap.put("pnum", paper.getPnum());
+        ztmap.put("pscore", paper.getPscore());
+        ztmap.put("ranglist", ranglist);
+
+        // 题型分布(按照名称进行分组)
+        fjtypelist.sort(Comparator.comparing(MsPaperQtypeVo::getMptorder));
+        Map<String, List<MsPaperQtypeVo>> qtypemap = fjtypelist.stream().collect(Collectors.groupingBy(MsPaperQtypeVo::getMptname, Collectors.toList()));
+        List<Map<String, Object>> qtlist = new ArrayList<>();
+        for (Map.Entry<String, List<MsPaperQtypeVo>> entry : qtypemap.entrySet()) {
+            List<MsPaperQtypeVo> aq = entry.getValue();
+            int num = aq.stream().mapToInt(MsPaperQtypeVo::getMptnum).sum();
+            double tscore = aq.stream().mapToDouble(MsPaperQtypeVo::getMptscore).sum();
+            tscore = N_Utils.formatDouble(tscore, 1);
+            double storerate = N_Utils.getDoubleDivideAndMulitiply(tscore, paper.getPscore());
+            // 获取小题题号
+
+            List<Integer> orderlist = new ArrayList<>();
+            List<Integer> mptqidlist = new ArrayList<>();
+            List<String> qnlist = new ArrayList<>();
+            List<Double> scorelist = new ArrayList<>();
+            List<String> qnamelist = new ArrayList<>();
+            for (MsPaperQtypeVo t : aq) {
+                List<MsPaperQtypeQuestionVo> qlist = t.getQuestions();
+                for (MsPaperQtypeQuestionVo q : qlist) {
+                    orderlist.add(q.getQorder());
+                    mptqidlist.add(q.getMptqid());
+                    qnlist.add(q.getQn());
+                    scorelist.add(q.getQscore());
+                    qnamelist.add(q.getQtypename());
+                }
+            }
+
+            Map<String, Object> anmap = new TreeMap<>();// 题型对应试题的id和基础信息
+            anmap.put("orders", orderlist);
+            anmap.put("mptqids", mptqidlist);
+            anmap.put("qns", qnlist);
+            anmap.put("scores", scorelist);
+            anmap.put("qtypenames", qnamelist);
+
+            Map<String, Object> tmap = new TreeMap<>();
+            tmap.put("qtname", entry.getKey());
+            tmap.put("qtid", aq.get(0).getMptid());
+            tmap.put("num", num);
+            tmap.put("score", tscore);
+            tmap.put("srate", storerate);
+            tmap.put("ques", anmap);
+            qtlist.add(tmap);
+        }
+
+        // 试卷中试题难易度
+        String complexityJson = null;
+        List<MsPaperQtypeQuestionVo> hasComplexitys = queslist.stream().filter(q -> N_Utils.isTrueInteger(q.getComplexity())).collect(Collectors.toList());
+        if (!hasComplexitys.isEmpty()) {
+            Map<Integer, List<MsPaperQtypeQuestionVo>> complexmap = queslist.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestionVo::getComplexity, Collectors.toList()));
+            List<Map<String, Object>> clist = new ArrayList<>();
+            for (Map.Entry<Integer, List<MsPaperQtypeQuestionVo>> entry : complexmap.entrySet()) {
+                List<MsPaperQtypeQuestionVo> pgblist = entry.getValue();
+                // 处理需要保存的ques集合
+                List<Map<String, Object>> quesList = new ArrayList<>();
+                for (MsPaperQtypeQuestionVo q : pgblist) {
+                    Map<String, Object> qmap = new TreeMap<>();
+                    qmap.put("id", entry.getKey());
+                    qmap.put("mptqid", q.getMptqid());
+                    qmap.put("order", q.getQorder());
+                    qmap.put("qlevel", 1);
+                    qmap.put("qns", q.getQn());
+                    qmap.put("score", q.getQscore());
+
+                    quesList.add(qmap);
+                }
+
+                Double score = pgblist.stream().mapToDouble(MsPaperQtypeQuestionVo::getQscore).sum();
+                score = N_Utils.formatDouble(score, 1);
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
+                Map<String, Object> prate = new TreeMap<>();
+                prate.put("level", entry.getKey());
+                prate.put("score", score);
+                prate.put("srate", srate);
+                prate.put("ques", quesList);
+                clist.add(prate);
+            }
+            complexityJson = JSON.toJSONString(clist);
+        }
+
+        // 试卷中试题知识点
+        String pointJson = null;
+        String quesPointJson = null;
+        if (N_Utils.isListNotEmpty(pointqlist)) {
+            List<Map<String, Object>> pointlist = new ArrayList<>();
+            LinkedHashMap<String, List<QuestionOrderVo>> pointmap = pointqlist.stream().collect(Collectors.groupingBy(QuestionOrderVo::getId, LinkedHashMap::new,
+                                                                                                                      Collectors.toList()));
+            // 根据指示进行分组，
+            for (Map.Entry<String, List<QuestionOrderVo>> entry : pointmap.entrySet()) {
+                List<QuestionOrderVo> pgblist = entry.getValue();
+                // 获取知识点的总分
+                Double score = pgblist.stream().mapToDouble(QuestionOrderVo::getScore).sum();
+                score = N_Utils.formatDouble(score, 1);
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
+                Map<String, Object> prate = new LinkedHashMap<>();
+                prate.put("pointid", entry.getKey());
+                prate.put("pointname", pgblist.get(0).getName());
+                prate.put("score", score);
+                prate.put("srate", srate);
+                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
+                pointlist.add(prate);
+            }
+
+            pointJson = JSON.toJSONString(pointlist);
+            quesPointJson = JSON.toJSONString(quesplist);
+        }
+
+        MsPaperAnalyze epa = new MsPaperAnalyze();
+        epa.setMpid(paper.getMpid());
+        epa.setAlljson(JSON.toJSONString(ztmap));
+        epa.setQnumjson(JSON.toJSONString(qtlist));
+        epa.setComplexityjson(complexityJson);
+        epa.setPointjson(pointJson);
+        epa.setQuespointjson(quesPointJson);
+
+        // 判断试卷你是否有分析，如果没有直接保存
+        MsPaperAnalyze existEpa = msPaperAnalyzeMapper.getObjByMpId(paper.getMpid());
+        if (existEpa == null || !N_Utils.isTrueInteger(existEpa.getMpaid())) {
+            msPaperAnalyzeMapper.insertUseGeneratedKeys(epa);
+        } else {
+            epa.setMpaid(existEpa.getMpaid());
+            msPaperAnalyzeMapper.updateByPrimaryKey(epa);
+        }
+    }
+
+}
+
+

smarking/src/main/java/com/xhkjedu/smarking/service/paper/MsPaperQtypeService.java

@@ -1,6 +1,5 @@
 package com.xhkjedu.smarking.service.paper;
 
-import com.alibaba.fastjson.JSON;
 import com.xhkjedu.exception.MissingParametersException;
 import com.xhkjedu.smarking.mapper.exam.MsSubjectMapper;
 import com.xhkjedu.smarking.mapper.paper.*;
@@ -22,7 +21,10 @@ import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
 import java.util.stream.Collectors;
 
 /**
@@ -57,6 +59,8 @@ public class MsPaperQtypeService {
     private MsPaperStudentMapper msPaperStudentMapper;
     @Resource
     private MsPaperCheckTeacherMapper msPaperCheckTeacherMapper;
+    @Resource
+    private MsPaperAnalyzeService msPaperAnalyzeService;
     private final ConvertUtil convertUtil;
 
     public MsPaperQtypeService(ConvertUtil convertUtil) {
@@ -104,14 +108,14 @@ public class MsPaperQtypeService {
         List<String> imgs = new ArrayList<>();
         // 保存试卷分析
         if (paper.getPtype() == 1) {
-            savePaperAnalyzeForQuestion(paper);
+            msPaperAnalyzeService.savePaperAnalyzeForQuestion(paper);
         } else {
             List<MsPaperFile> pfiles = paper.getPfiles();// 附件
             if (paper.getYjstate() == 1) {
                 setPaperFiles(paper, pfiles, imgs);
                 msPaperFileMapper.insertList(pfiles);
             }
-            savePaperAnalyzeForFj(paper);
+            msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
         }
 
         // 更改科目状态
@@ -215,459 +219,7 @@ public class MsPaperQtypeService {
         msPaperQtypeQuestionMapper.insertList(qtqs);
     }
 
-    // 保存试卷分析--题库
-    private void savePaperAnalyzeForQuestion(MsPaper paper) {
-        Integer mpid = paper.getMpid();
-
-        // 总体分析（主观题、客观题）
-        List<MsPaperQtypeVo> qtypelist = msPaperQtypeMapper.listPaperQtypeQuestions(paper.getMpid());// 试卷题型试题信息
-        List<MsPaperQtypeQuestion> uplist = new ArrayList<>();// 改试卷中客观题选项数量
-        List<MsPaperQtypeQuestion> upComplexitylist = new ArrayList<>();// 改试卷中客观题难易度
-        List<MsPaperQtypeQuestionPoint> upQpointlist = new ArrayList<>();// 保存试卷中试题知识点关联关系
-
-        List<QuestionOrderVo> pointqlist = new ArrayList<>();// 用于存放知识点，以及知识点下得分
-        List<MsPaperQtypeQuestionVo> mquestions = new ArrayList<>();// 存放单题和母题
-        List<QuestionOrderVo> complexitylist = new ArrayList<>();// 试题难易度存放试题
-        List<QuestionPointVo> quesplist = new ArrayList<>();// 单题、母题对应知识点
-
-        // 处理出试卷中所有试题、知识点
-        List<Map<String, Object>> typelist = new ArrayList<>();// 题型分析
-        for (MsPaperQtypeVo qt : qtypelist) {
-            List<Integer> qorderlist = new ArrayList<>();
-            List<QuestionOrderVo> qtypeqlist = new ArrayList<>();
-            List<MsPaperQtypeQuestionVo> tqlist = qt.getQuestions();
-            int hasmt = 0;
-            for (MsPaperQtypeQuestionVo q : tqlist) {
-                int ctype = q.getCtype();
-                // 单题的pid设置为默认值，方便后续进行单题和母题处理
-                if (q.getQlevel() == 1) {
-                    q.setQuestionpid("000");
-                    // 判断试题是否是客观题
-                    if (N_Utils.isObjectiveQuestion(ctype)) {
-                        // 判断试题是否是客观题,暂时用mctype进行标识
-                        q.setMctype(111);
-                    } else {
-                        q.setMctype(112);
-                    }
-                    // 设置知识点
-                    mquestions.add(q);
-                    // 获取试题知识点
-                    List<Map<String, Object>> qpoints = q.getPoints();
-                    // 处理试题知识点占分
-                    setPaperQuestionPointScore(pointqlist, quesplist, qpoints, q, null, null);
-                    setPaperQuestionPointRelation(qpoints, q, null, upQpointlist, mpid);
-                    setPaperQuestionQtypeScore(qtypeqlist, q, null, null);// 处理试题题型
-                    setPaperQuestionComplexityScore(complexitylist, q, null, null, upComplexitylist);// 处理试题难易度
-
-                }
-                if (q.getQlevel() == 3) {
-                    hasmt++;
-                }
-                if (!qorderlist.contains(q.getQorder())) {
-                    qorderlist.add(q.getQorder());
-                }
-                // 为了处理客观题中选项数量
-                if (ctype == 1 || ctype == 2 || ctype == 4 || ctype == 5 || ctype == 6) {
-                    List<String> strlst = JSON.parseArray(q.getQoption(), String.class);
-                    MsPaperQtypeQuestion eqq = new MsPaperQtypeQuestion();
-                    eqq.setMptqid(q.getMptqid());
-                    eqq.setOptionnum(strlst.size());
-                    uplist.add(eqq);
-                }
-            }
-
-            if (hasmt > 0) {
-                // 说明该题型下有复合题,复合体进行知识点、题型下试题题号及id进行操作
-                LinkedHashMap<String, List<MsPaperQtypeQuestionVo>> quesMap = tqlist.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestionVo::getQuestionpid,
-                                                                                                                            LinkedHashMap::new, Collectors.toList()));
-                for (Map.Entry<String, List<MsPaperQtypeQuestionVo>> entry : quesMap.entrySet()) {
-                    if (!entry.getKey().equals("000")) {
-                        // 说明该题为母题，
-                        MsPaperQtypeQuestionVo mq = new MsPaperQtypeQuestionVo();
-                        List<MsPaperQtypeQuestionVo> sonques = entry.getValue();
-                        int k = 0;// 如果k大于1说明有小题是主观题，则母题为主观题
-                        double score = 0;
-                        for (MsPaperQtypeQuestionVo sq : sonques) {
-                            if (!N_Utils.isObjectiveQuestion(sq.getCtype())) {
-                                k++;
-                            }
-                            score = N_Utils.getDoubleSum(score, sq.getQscore());
-                        }
-
-                        MsPaperQtypeQuestionVo qobj = sonques.get(0);
-                        mq.setQuestionid(qobj.getQuestionpid());
-                        mq.setComplexity(qobj.getMcomplexity());
-                        mq.setQorder(qobj.getQorder());
-                        mq.setQscore(score);
-                        mq.setQtypename(qobj.getMqtypename());
-                        if (k == 0) {
-                            mq.setMctype(111);
-                        } else {
-                            mq.setMctype(112);
-                        }
-                        mq.setQlevel(qobj.getMqlevel());
-                        mq.setSonques(sonques);
-                        // 获取所有子题的试题题号
-                        String[] qnstr = sonques.stream().map(MsPaperQtypeQuestionVo::getQn).toArray(String[]::new);
-                        // 所有子题的试题eptqid
-                        List<Integer> eptqids = sonques.stream().map(MsPaperQtypeQuestionVo::getMptqid).collect(Collectors.toList());
-                        Integer[] eptqidstr = eptqids.toArray(new Integer[0]);
-
-                        // 获取知识点
-                        List<Map<String, Object>> qpoints = sonques.get(0).getPoints();
-                        mq.setPoints(qpoints);
-                        mquestions.add(mq);
-                        setPaperQuestionPointScore(pointqlist, quesplist, qpoints, mq, qnstr, eptqids);
-                        setPaperQuestionPointRelation(qpoints, mq, eptqids, upQpointlist, mpid);
-                        setPaperQuestionQtypeScore(qtypeqlist, mq, qnstr, eptqidstr);// 处理试题题型
-                        setPaperQuestionComplexityScore(complexitylist, mq, qnstr, eptqidstr, upComplexitylist);// 处理试题难易度
-                    }
-                }
-            }
 
-            // 试题题型分析数据
-            double storerate = N_Utils.getDoubleDivideAndMulitiply(qt.getMptscore(), paper.getPscore());
-            Map<String, Object> tmap = new TreeMap<>();
-            tmap.put("qtid", qt.getMptid());
-            tmap.put("qtname", qt.getMptname());
-            tmap.put("num", qt.getMptnum());
-            tmap.put("score", qt.getMptscore());
-            tmap.put("srate", storerate);
-            qtypeqlist = qtypeqlist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList());
-            tmap.put("ques", qtypeqlist);
-            typelist.add(tmap);
-        }
-
-        // 进行客观题选项处理
-        if (N_Utils.isListNotEmpty(uplist)) {
-            msPaperQtypeQuestionMapper.updateBatchQuestionOptionnum(uplist);
-        }
-
-        // 试题总体分布进行分析
-        // 客观题集合
-        List<MsPaperQtypeQuestionVo> ktlst = mquestions.stream().filter(q -> q.getMctype() == 111).collect(Collectors.toList());
-        int ktnum = ktlst.size();
-        double ktscore = ktlst.stream().mapToDouble(MsPaperQtypeQuestionVo::getQscore).sum();
-        double ktnrate = N_Utils.getIntegerDivideAndMulitiply(ktnum, paper.getPnum());
-        double ktsrate = N_Utils.getDoubleDivideAndMulitiply(ktscore, paper.getPscore());
-        List<MsPaperQsVo> ranglist = new ArrayList<>();
-        ranglist.add(new MsPaperQsVo("客观题", ktscore, ktnum, ktsrate, ktnrate));
-        MsPaperQsVo zgq = new MsPaperQsVo();
-        zgq.setQtname("主观题");
-        zgq.setNum(paper.getPnum() - ktnum);
-        zgq.setNrate(N_Utils.getDoubleReduce(100.0, ktnrate));
-        zgq.setScore(N_Utils.getDoubleReduce(paper.getPscore(), ktscore));
-        zgq.setSrate(N_Utils.getDoubleReduce(100.0, ktsrate));
-        ranglist.add(zgq);
-        Map<String, Object> ztmap = new TreeMap<>();
-        ztmap.put("pnum", paper.getPnum());
-        ztmap.put("pscore", paper.getPscore());
-        ztmap.put("ranglist", ranglist);
-
-        // 设置试卷中试题难易度
-        msPaperQtypeQuestionMapper.updateBatchQuestionComplexity(upComplexitylist);
-
-        // 难易度
-        List<Map<String, Object>> clist = new ArrayList<>();
-        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(QuestionOrderVo::getScore).sum();
-                score = N_Utils.formatDouble(score, 1);
-                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
-                Map<String, Object> prate = new TreeMap<>();
-                prate.put("level", Integer.parseInt(entry.getKey()));
-                prate.put("score", score);
-                prate.put("srate", srate);
-                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
-                clist.add(prate);
-            }
-        }
-
-        // 保存试卷试题知识点关系
-        msPaperQtypeQuestionPointMapper.deleteByMpid(mpid);
-        msPaperQtypeQuestionPointMapper.insertList(upQpointlist);
-
-        // 知识点分析
-        List<Map<String, Object>> pointlist = new ArrayList<>();
-        if (N_Utils.isListNotEmpty(pointqlist)) {
-            LinkedHashMap<String, List<QuestionOrderVo>> pointmap = pointqlist.stream().collect(Collectors.groupingBy(QuestionOrderVo::getId, LinkedHashMap::new,
-                                                                                                                      Collectors.toList()));
-            // 根据指示进行分组，
-            for (Map.Entry<String, List<QuestionOrderVo>> entry : pointmap.entrySet()) {
-                List<QuestionOrderVo> pgblist = entry.getValue();
-                // 获取知识点的总分
-                Double score = pgblist.stream().mapToDouble(QuestionOrderVo::getScore).sum();
-                score = N_Utils.formatDouble(score, 1);
-                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
-                Map<String, Object> prate = new LinkedHashMap<>();
-                prate.put("pointid", entry.getKey());
-                prate.put("pointname", pgblist.get(0).getName());
-                prate.put("score", score);
-                prate.put("srate", srate);
-                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
-                pointlist.add(prate);
-            }
-        }
-
-        MsPaperAnalyze epa = new MsPaperAnalyze();
-        epa.setMpid(paper.getMpid());
-        epa.setAlljson(JSON.toJSONString(ztmap));// 总体分析
-        epa.setQnumjson(JSON.toJSONString(typelist));// 试题栏题型分析
-        epa.setComplexityjson(JSON.toJSONString(clist));// 难易度分析
-        epa.setPointjson(JSON.toJSONString(pointlist));// 知识点分析
-        epa.setQuespointjson(JSON.toJSONString(quesplist));
-
-        // 判断试卷你是否有分析，如果没有直接保存
-        MsPaperAnalyze existEpa = msPaperAnalyzeMapper.getObjByMpId(paper.getMpid());
-        if (existEpa == null || !N_Utils.isTrueInteger(existEpa.getMpaid())) {
-            msPaperAnalyzeMapper.insertUseGeneratedKeys(epa);
-        } else {
-            epa.setMpaid(existEpa.getMpaid());
-            msPaperAnalyzeMapper.updateByPrimaryKey(epa);
-        }
-    }
-
-    // 设置知识点
-    private void setPaperQuestionPointScore(List<QuestionOrderVo> pointqlist, List<QuestionPointVo> quesplist, List<Map<String, Object>> qpoints, MsPaperQtypeQuestionVo dq,
-                                            String[] qnstr, List<Integer> mptqids) {
-        if (N_Utils.isListNotEmpty(qpoints)) {
-            if (qpoints.size() == 1) {
-                // 试题只有一个知识点
-                Map<String, Object> pointmap = qpoints.get(0);
-                QuestionOrderVo qpoint = new QuestionOrderVo();
-                qpoint.setId(pointmap.get("pointid").toString());
-                qpoint.setName(pointmap.get("pointname").toString());
-                qpoint.setOrder(dq.getQorder());
-                qpoint.setScore(dq.getQscore());
-                qpoint.setQlevel(dq.getQlevel());
-                qpoint.setQuestionid(dq.getQuestionid());
-                if (qnstr == null) {
-                    qpoint.setQns(new String[]{dq.getQn()});
-                } else {
-                    qpoint.setQns(qnstr);
-                }
-
-                if (N_Utils.isListEmpty(mptqids)) {
-                    qpoint.setMptqids(new Integer[]{dq.getMptqid()});
-                } else {
-                    Integer[] mptqidstr = mptqids.toArray(new Integer[0]);
-                    qpoint.setMptqids(mptqidstr);
-                }
-                pointqlist.add(qpoint);
-
-                // 试题对应知识点
-                QuestionPointVo questionPointVo = new QuestionPointVo();
-                questionPointVo.setOrder(dq.getQorder());
-                questionPointVo.setScore(dq.getQscore());
-                questionPointVo.setQlevel(dq.getQlevel());
-                questionPointVo.setQuestionid(dq.getQuestionid());
-                List<Map<String, Object>> pointids = new ArrayList<>();
-                Map<String, Object> map = new HashMap<>();
-                map.put("pointid", pointmap.get("pointid").toString());
-                map.put("score", dq.getQscore());
-                pointids.add(map);
-                questionPointVo.setPointids(pointids);
-
-                if (N_Utils.isListEmpty(mptqids)) {
-                    List<Integer> saveids = new ArrayList<>();
-                    saveids.add(dq.getMptqid());
-                    questionPointVo.setMptqids(saveids);
-                    questionPointVo.setMptqid(dq.getMptqid());
-                } else {
-                    questionPointVo.setMptqids(mptqids);
-                    questionPointVo.setMptqid(0);
-                }
-                quesplist.add(questionPointVo);
-            } else {
-
-                // 试题有多个知识点
-                // 计算每个知识点所占分值（平均分配）
-                Double[] avgps = N_Utils.getPointAvgScore(qpoints.size(), dq.getQscore());
-                List<Map<String, Object>> pointids = new ArrayList<>();
-                for (int m = 0; m < qpoints.size(); m++) {
-                    Map<String, Object> pointmap = qpoints.get(m);
-                    QuestionOrderVo qpoint = new QuestionOrderVo();
-                    qpoint.setId(pointmap.get("pointid").toString());
-                    qpoint.setName(pointmap.get("pointname").toString());
-                    qpoint.setOrder(dq.getQorder());
-                    qpoint.setQlevel(dq.getQlevel());
-                    qpoint.setQuestionid(dq.getQuestionid());
-
-
-                    Map<String, Object> quesmap = new HashMap<>();// 试题对应知识点
-                    quesmap.put("pointid", pointmap.get("pointid").toString());
-
-                    if (avgps.length == 2 && (m + 1) == qpoints.size()) {
-                        // 不能整除分，并且是最后一个知识点
-                        qpoint.setScore(avgps[1]);
-                        quesmap.put("score", avgps[1]);
-                    } else {
-                        qpoint.setScore(avgps[0]);
-                        quesmap.put("score", avgps[0]);
-                    }
-                    pointids.add(quesmap);
-
-                    // 题号集合
-                    if (qnstr == null) {
-                        qpoint.setQns(new String[]{dq.getQn()});
-                    } else {
-                        qpoint.setQns(qnstr);
-                    }
-                    // 试卷中试题id集合
-                    if (N_Utils.isListEmpty(mptqids)) {
-                        qpoint.setMptqids(new Integer[]{dq.getMptqid()});
-                    } else {
-                        Integer[] eptqidstr = mptqids.toArray(new Integer[0]);
-                        qpoint.setMptqids(eptqidstr);
-                    }
-                    pointqlist.add(qpoint);
-                }
-
-                // 试题对应知识点
-                QuestionPointVo questionPointVo = new QuestionPointVo();
-                questionPointVo.setOrder(dq.getQorder());
-                questionPointVo.setScore(dq.getQscore());
-                questionPointVo.setQlevel(dq.getQlevel());
-                questionPointVo.setQuestionid(dq.getQuestionid());
-                questionPointVo.setPointids(pointids);
-                if (N_Utils.isListEmpty(mptqids)) {
-                    List<Integer> saveids = new ArrayList<>();
-                    saveids.add(dq.getMptqid());
-                    questionPointVo.setMptqids(saveids);
-                    questionPointVo.setMptqid(dq.getMptqid());
-
-                } else {
-                    questionPointVo.setMptqids(mptqids);
-                    questionPointVo.setMptqid(0);
-                }
-                quesplist.add(questionPointVo);
-
-            }
-
-        } else {
-            QuestionPointVo questionPointVo = new QuestionPointVo();
-            questionPointVo.setOrder(dq.getQorder());
-            questionPointVo.setScore(dq.getQscore());
-            questionPointVo.setQlevel(dq.getQlevel());
-            questionPointVo.setQuestionid(dq.getQuestionid());
-            questionPointVo.setPointids(null);
-            if (N_Utils.isListEmpty(mptqids)) {
-                List<Integer> saveids = new ArrayList<>();
-                saveids.add(dq.getMptqid());
-                questionPointVo.setMptqids(saveids);
-                questionPointVo.setMptqid(dq.getMptqid());
-            } else {
-                questionPointVo.setMptqids(mptqids);
-                questionPointVo.setMptqid(0);
-            }
-
-            quesplist.add(questionPointVo);
-        }
-    }
-
-    // 设置知识点--试卷试题知识点关联关系
-    private void setPaperQuestionPointRelation(List<Map<String, Object>> qpoints, MsPaperQtypeQuestionVo dq, List<Integer> mptqids, List<MsPaperQtypeQuestionPoint> upQpointlist,
-                                               Integer mpid) {
-        if (N_Utils.isListNotEmpty(qpoints)) {
-            // 试题对应知识点关系
-            int i = 0;
-            for (Map<String, Object> pointmap : qpoints) {
-                String pointid = pointmap.get("pointid").toString();
-                String pointname = pointmap.get("pointname").toString();
-
-                if (N_Utils.isListEmpty(mptqids)) {
-                    MsPaperQtypeQuestionPoint upPoint = new MsPaperQtypeQuestionPoint();
-                    upPoint.setMpid(mpid);
-                    upPoint.setMptqid(dq.getMptqid());
-                    upPoint.setPointid(pointid);
-                    upPoint.setPointname(pointname);
-                    upPoint.setMporder(i++);
-
-                    upQpointlist.add(upPoint);
-                } else {
-                    for (Integer mptqid : mptqids) {
-                        MsPaperQtypeQuestionPoint upPoint = new MsPaperQtypeQuestionPoint();
-                        upPoint.setMpid(mpid);
-                        upPoint.setMptqid(mptqid);
-                        upPoint.setPointid(pointid);
-                        upPoint.setPointname(pointname);
-                        upPoint.setMporder(i++);
-
-                        upQpointlist.add(upPoint);
-                    }
-                }
-            }
-        }
-
-    }
-
-    // 设置题型下试题题号及分值
-    private void setPaperQuestionQtypeScore(List<QuestionOrderVo> qtypelist, MsPaperQtypeQuestionVo dq, String[] qnstr, Integer[] mptqidstr) {
-        QuestionOrderVo qtype = new QuestionOrderVo();
-        qtype.setId(dq.getQtypeid());
-        qtype.setName(dq.getQtypename());
-        qtype.setComplexity(dq.getComplexity());
-        qtype.setOrder(dq.getQorder());
-        qtype.setScore(dq.getQscore());
-        qtype.setQlevel(dq.getQlevel());
-        qtype.setQuestionid(dq.getQuestionid());
-        if (qnstr == null) {
-            qtype.setQns(new String[]{dq.getQn()});
-        } else {
-            qtype.setQns(qnstr);
-        }
-        if (mptqidstr == null) {
-            qtype.setMptqids(new Integer[]{dq.getMptqid()});
-        } else {
-            qtype.setMptqids(mptqidstr);
-        }
-
-        qtypelist.add(qtype);
-    }
-
-    // 设置试题难易度
-    private void setPaperQuestionComplexityScore(List<QuestionOrderVo> complexityList, MsPaperQtypeQuestionVo dq, String[] qnstr, Integer[] mptqidstr,
-                                                 List<MsPaperQtypeQuestion> upComplexitylist) {
-        QuestionOrderVo qtype = new QuestionOrderVo();
-        qtype.setId(dq.getComplexity().toString());// 存放试题难易度
-        qtype.setOrder(dq.getQorder());
-        qtype.setScore(dq.getQscore());
-        qtype.setQlevel(dq.getQlevel());
-        qtype.setQuestionid(dq.getQuestionid());
-        if (qnstr == null) {
-            qtype.setQns(new String[]{dq.getQn()});
-        } else {
-            qtype.setQns(qnstr);
-        }
-
-        if (mptqidstr == null) {
-            qtype.setMptqids(new Integer[]{dq.getMptqid()});
-        } else {
-            qtype.setMptqids(mptqidstr);
-        }
-
-        complexityList.add(qtype);
-        // 设置试题难易度
-        if (mptqidstr == null) {
-            MsPaperQtypeQuestion upComplexity = new MsPaperQtypeQuestion();
-            upComplexity.setMptqid(dq.getMptqid());
-            upComplexity.setComplexity(dq.getComplexity());
-
-            upComplexitylist.add(upComplexity);
-        } else {
-            for (Integer mptqid : mptqidstr) {
-                MsPaperQtypeQuestion upComplexity = new MsPaperQtypeQuestion();
-                upComplexity.setMptqid(mptqid);
-                upComplexity.setComplexity(dq.getComplexity());
-
-                upComplexitylist.add(upComplexity);
-            }
-        }
-
-
-    }
 
     // 设置附件
     private void setPaperFiles(MsPaper paper, List<MsPaperFile> pfiles, List<String> imgs) {
@@ -694,191 +246,7 @@ public class MsPaperQtypeService {
 
     }
 
-    // 保存试卷分析--附件
-    private void savePaperAnalyzeForFj(MsPaper paper) {
-        List<MsPaperQtypeVo> fjtypelist = msPaperQtypeMapper.listPaperQtypeQuesitonsForFj(paper.getMpid());
-        List<MsPaperQtypeQuestionVo> queslist = new ArrayList<>();
-        for (MsPaperQtypeVo fj : fjtypelist) {
-            List<MsPaperQtypeQuestionVo> qlist = fj.getQuestions();
-            queslist.addAll(qlist);
-        }
 
-        List<QuestionOrderVo> pointqlist = new ArrayList<>();// 用于存放知识点，以及知识点下得分
-        List<QuestionPointVo> quesplist = new ArrayList<>();// 单题对应知识点
-
-        // 总体分析（主观题、客观题）
-        // 处理题型1单选题2多选题3主观题4判断对错5判断√×6判断TF11综合题12听力13填空题
-        int znum = 0;
-        double zscore = 0;
-        int knum = 0;
-        double kscore = 0;
-        for (MsPaperQtypeQuestionVo q : queslist) {
-            if (N_Utils.isObjectiveQuestion(q.getCtype())) {
-                knum++;
-                kscore = kscore + q.getQscore();
-            } else {
-                znum++;
-                zscore = zscore + q.getQscore();
-            }
-
-            List<Map<String, Object>> qpoints = q.getPoints();
-            if(qpoints != null) {
-                // 存放知识点
-                setPaperQuestionPointScore(pointqlist, quesplist, qpoints, q, null, null);
-            }
-        }
-
-        double znumrate = N_Utils.getIntegerDivideAndMulitiply(znum, paper.getPnum());
-        double knumrate = N_Utils.getDoubleReduce(100.0, znumrate);
-
-        double zscorerate = N_Utils.getDoubleDivideAndMulitiply(zscore, paper.getPscore());
-        double kscorerate = N_Utils.getDoubleReduce(100.0, zscorerate);
-
-        List<Map<String, Object>> ranglist = new ArrayList<>();
-        Map<String, Object> zgmap = new TreeMap<>();
-        zgmap.put("qtname", "主观题");
-        zgmap.put("score", zscore);
-        zgmap.put("num", znum);
-        zgmap.put("srate", zscorerate);
-        zgmap.put("nrate", znumrate);
-        ranglist.add(zgmap);
-        Map<String, Object> kgmap = new TreeMap<>();
-        kgmap.put("qtname", "客观题");
-        kgmap.put("score", kscore);
-        kgmap.put("num", knum);
-        kgmap.put("srate", kscorerate);
-        kgmap.put("nrate", knumrate);
-        ranglist.add(kgmap);
-
-        Map<String, Object> ztmap = new TreeMap<>();
-        ztmap.put("pnum", paper.getPnum());
-        ztmap.put("pscore", paper.getPscore());
-        ztmap.put("ranglist", ranglist);
-
-        // 题型分布(按照名称进行分组)
-        fjtypelist.sort(Comparator.comparing(MsPaperQtypeVo::getMptorder));
-        Map<String, List<MsPaperQtypeVo>> qtypemap = fjtypelist.stream().collect(Collectors.groupingBy(MsPaperQtypeVo::getMptname, Collectors.toList()));
-        List<Map<String, Object>> qtlist = new ArrayList<>();
-        for (Map.Entry<String, List<MsPaperQtypeVo>> entry : qtypemap.entrySet()) {
-            List<MsPaperQtypeVo> aq = entry.getValue();
-            int num = aq.stream().mapToInt(MsPaperQtypeVo::getMptnum).sum();
-            double tscore = aq.stream().mapToDouble(MsPaperQtypeVo::getMptscore).sum();
-            tscore = N_Utils.formatDouble(tscore, 1);
-            double storerate = N_Utils.getDoubleDivideAndMulitiply(tscore, paper.getPscore());
-            // 获取小题题号
-
-            List<Integer> orderlist = new ArrayList<>();
-            List<Integer> mptqidlist = new ArrayList<>();
-            List<String> qnlist = new ArrayList<>();
-            List<Double> scorelist = new ArrayList<>();
-            List<String> qnamelist = new ArrayList<>();
-            for (MsPaperQtypeVo t : aq) {
-                List<MsPaperQtypeQuestionVo> qlist = t.getQuestions();
-                for (MsPaperQtypeQuestionVo q : qlist) {
-                    orderlist.add(q.getQorder());
-                    mptqidlist.add(q.getMptqid());
-                    qnlist.add(q.getQn());
-                    scorelist.add(q.getQscore());
-                    qnamelist.add(q.getQtypename());
-                }
-            }
-
-            Map<String, Object> anmap = new TreeMap<>();// 题型对应试题的id和基础信息
-            anmap.put("orders", orderlist);
-            anmap.put("mptqids", mptqidlist);
-            anmap.put("qns", qnlist);
-            anmap.put("scores", scorelist);
-            anmap.put("qtypenames", qnamelist);
-
-            Map<String, Object> tmap = new TreeMap<>();
-            tmap.put("qtname", entry.getKey());
-            tmap.put("qtid", aq.get(0).getMptid());
-            tmap.put("num", num);
-            tmap.put("score", tscore);
-            tmap.put("srate", storerate);
-            tmap.put("ques", anmap);
-            qtlist.add(tmap);
-        }
-
-        // 试卷中试题难易度
-        String complexityJson = null;
-        List<MsPaperQtypeQuestionVo> hasComplexitys = queslist.stream().filter(q -> N_Utils.isTrueInteger(q.getComplexity())).collect(Collectors.toList());
-        if (!hasComplexitys.isEmpty()) {
-            Map<Integer, List<MsPaperQtypeQuestionVo>> complexmap = queslist.stream().collect(Collectors.groupingBy(MsPaperQtypeQuestionVo::getComplexity, Collectors.toList()));
-            List<Map<String, Object>> clist = new ArrayList<>();
-            for (Map.Entry<Integer, List<MsPaperQtypeQuestionVo>> entry : complexmap.entrySet()) {
-                List<MsPaperQtypeQuestionVo> pgblist = entry.getValue();
-                // 处理需要保存的ques集合
-                List<Map<String, Object>> quesList = new ArrayList<>();
-                for (MsPaperQtypeQuestionVo q : pgblist) {
-                    Map<String, Object> qmap = new TreeMap<>();
-                    qmap.put("id", entry.getKey());
-                    qmap.put("mptqid", q.getMptqid());
-                    qmap.put("order", q.getQorder());
-                    qmap.put("qlevel", 1);
-                    qmap.put("qns", q.getQn());
-                    qmap.put("score", q.getQscore());
-
-                    quesList.add(qmap);
-                }
-
-                Double score = pgblist.stream().mapToDouble(MsPaperQtypeQuestionVo::getQscore).sum();
-                score = N_Utils.formatDouble(score, 1);
-                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
-                Map<String, Object> prate = new TreeMap<>();
-                prate.put("level", entry.getKey());
-                prate.put("score", score);
-                prate.put("srate", srate);
-                prate.put("ques", quesList);
-                clist.add(prate);
-            }
-            complexityJson = JSON.toJSONString(clist);
-        }
-
-        // 试卷中试题知识点
-        String pointJson = null;
-        String quesPointJson = null;
-        if (N_Utils.isListNotEmpty(pointqlist)) {
-            List<Map<String, Object>> pointlist = new ArrayList<>();
-            LinkedHashMap<String, List<QuestionOrderVo>> pointmap = pointqlist.stream().collect(Collectors.groupingBy(QuestionOrderVo::getId, LinkedHashMap::new,
-                                                                                                                      Collectors.toList()));
-            // 根据指示进行分组，
-            for (Map.Entry<String, List<QuestionOrderVo>> entry : pointmap.entrySet()) {
-                List<QuestionOrderVo> pgblist = entry.getValue();
-                // 获取知识点的总分
-                Double score = pgblist.stream().mapToDouble(QuestionOrderVo::getScore).sum();
-                score = N_Utils.formatDouble(score, 1);
-                Double srate = N_Utils.getDoubleDivideAndMulitiply(score, paper.getPscore());
-                Map<String, Object> prate = new LinkedHashMap<>();
-                prate.put("pointid", entry.getKey());
-                prate.put("pointname", pgblist.get(0).getName());
-                prate.put("score", score);
-                prate.put("srate", srate);
-                prate.put("ques", pgblist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList()));
-                pointlist.add(prate);
-            }
-
-            pointJson = JSON.toJSONString(pointlist);
-            quesPointJson = JSON.toJSONString(quesplist);
-        }
-
-        MsPaperAnalyze epa = new MsPaperAnalyze();
-        epa.setMpid(paper.getMpid());
-        epa.setAlljson(JSON.toJSONString(ztmap));
-        epa.setQnumjson(JSON.toJSONString(qtlist));
-        epa.setComplexityjson(complexityJson);
-        epa.setPointjson(pointJson);
-        epa.setQuespointjson(quesPointJson);
-
-        // 判断试卷你是否有分析，如果没有直接保存
-        MsPaperAnalyze existEpa = msPaperAnalyzeMapper.getObjByMpId(paper.getMpid());
-        if (existEpa == null || !N_Utils.isTrueInteger(existEpa.getMpaid())) {
-            msPaperAnalyzeMapper.insertUseGeneratedKeys(epa);
-        } else {
-            epa.setMpaid(existEpa.getMpaid());
-            msPaperAnalyzeMapper.updateByPrimaryKey(epa);
-        }
-    }
 
 
     /*
@@ -1090,9 +458,7 @@ public class MsPaperQtypeService {
 
         // 保存完知识点难易度后，更新试卷分析
         MsPaper apaper = msPaperMapper.selectByPrimaryKey(mpid);
-        savePaperAnalyzeForFj(apaper);
-
-        // 生成考试报告中知识点难易度相关分析
+        msPaperAnalyzeService.savePaperAnalyzeForFj(apaper);
     }
 
     /*
@@ -1142,7 +508,7 @@ public class MsPaperQtypeService {
             List<MsPaperQtypeQuestionVo> qlist = qt.getQuestions();
             List<MsPaperQtypeQuestionVo> rtnqlist = new ArrayList<>();//保存处理后的试题
             String qpid = "";//母题id
-            List<MsPaperQtypeQuestionVo> sonqlist = new ArrayList<>();
+            List<MsPaperQtypeQuestionVo> sonqlist;
             for(MsPaperQtypeQuestionVo q : qlist){
                 //试题类型1单题2母题3子题
                 if(q.getQlevel() == 3){
@@ -1161,7 +527,7 @@ public class MsPaperQtypeService {
                         mq.setQlevel(q.getMqlevel());
                         mq.setHashear(q.getMhashear());
                         mq.setHearfile(q.getMhearfile());
-                        Double mscore = sonqlist.stream().collect(Collectors.summingDouble(MsPaperQtypeQuestionVo:: getQscore));
+                        Double mscore = sonqlist.stream().mapToDouble(MsPaperQtypeQuestionVo::getQscore).sum();
                         mq.setQscore(mscore);
 
                         for(MsPaperQtypeQuestionVo sonQ : sonqlist){
@@ -1302,7 +668,7 @@ public class MsPaperQtypeService {
         setPaperNumAndScore(paper);
         msPaperMapper.updateByPrimaryKeySelective(paper);
 
-        savePaperAnalyzeForFj(paper);
+        msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
 
         if (exam.getPstate() != 2) {
             // 更改科目状态
@@ -1384,7 +750,7 @@ public class MsPaperQtypeService {
         // 试卷中小题重新排序
         chandleQuestionOrder(paper);
 
-        savePaperAnalyzeForFj(paper);
+        msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
         deletePaperOtherInfo(mpid);
 
         return new ResultVo(0, "保存成功", paper.getMpid());
@@ -1414,7 +780,7 @@ public class MsPaperQtypeService {
         chandlePaperNumQtypeOrder(paper);
 
         // 重新生成试卷分析
-        savePaperAnalyzeForFj(paper);
+        msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
         return new ResultVo(0, "删除成功", paper.getMpid());
     }
 
@@ -1638,8 +1004,6 @@ public class MsPaperQtypeService {
         if (paper == null || !N_Utils.isTrueInteger(paper.getPnum())) {
             paper = msPaperMapper.selectByPrimaryKey(mpid);
         }
-        savePaperAnalyzeForFj(paper);
+        msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
     }
-
-
 }

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

@@ -2,11 +2,13 @@ package com.xhkjedu.smarking.service.report.generate;
 
 import com.alibaba.fastjson.JSON;
 import com.xhkjedu.smarking.mapper.paper.MsPaperAnalyzeMapper;
+import com.xhkjedu.smarking.mapper.paper.MsPaperMapper;
 import com.xhkjedu.smarking.mapper.report.reportstu.MsrStudentPointMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointRankgroupMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointSectionMapper;
 import com.xhkjedu.smarking.model.exam.MsClassStudent;
+import com.xhkjedu.smarking.model.paper.MsPaper;
 import com.xhkjedu.smarking.model.paper.MsPaperAnalyze;
 import com.xhkjedu.smarking.model.paper.MsPaperQtypeQuestion;
 import com.xhkjedu.smarking.model.report.reportstu.MsrStudent;
@@ -15,6 +17,7 @@ import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPoint;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointRankgroup;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPointSection;
 import com.xhkjedu.smarking.model.stupaper.MsPaperStudentQuestion;
+import com.xhkjedu.smarking.service.paper.MsPaperAnalyzeService;
 import com.xhkjedu.smarking.utils.MarkingUtil;
 import com.xhkjedu.smarking.vo.paper.QuestionPointVo;
 import com.xhkjedu.smarking.vo.report.reportother.RankGroupVo;
@@ -49,6 +52,10 @@ public class ReportGeneratePointService {
     private MsrSubjectPointRankgroupMapper msrSubjectPointRankgroupMapper;
     @Resource
     private MsrStudentPointMapper msrStudentPointMapper;
+    @Resource
+    private MsPaperMapper msPaperMapper;
+    @Resource
+    private MsPaperAnalyzeService msPaperAnalyzeService;
 
     //知识点分析，题库知识点按母题分析
     public void generatePoint(List<MsPaperStudentQuestion> stuSubjectQuestions, List<MsPaperQtypeQuestion> qtypeQuestions,List<MsClassStudent> classStus,
@@ -248,6 +255,24 @@ public class ReportGeneratePointService {
         classPoint.setJbzs(MarkingUtil.jbzs(stuScores, subjectPoint.getFullscore()));
         classPoint.setQns(subjectPoint.getQns());
         classPoint.setMptqids(subjectPoint.getMptqids());
+        //满分人
+        List<PointStudentVo> fullScoreStus = pointStuScores.stream().filter(q -> q.getStuscore().equals(subjectPoint.getFullscore())).collect(Collectors.toList());
+        if(fullScoreStus.isEmpty()){
+            classPoint.setMfnum(0);
+        }else{
+            classPoint.setMfnum(fullScoreStus.size());
+            classPoint.setMfids(fullScoreStus.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
+        }
+
+        //零分人
+        List<PointStudentVo> zeroScoreStus = pointStuScores.stream().filter(q -> q.getStuscore()==0).collect(Collectors.toList());
+        if(fullScoreStus.isEmpty()){
+            classPoint.setLfnum(0);
+        }else{
+            classPoint.setLfnum(zeroScoreStus.size());
+            classPoint.setLfids(zeroScoreStus.stream().map(q -> q.getStudentid().toString()).collect(Collectors.joining(",")));
+        }
+
         return classPoint;
     }
 
@@ -590,4 +615,21 @@ public class ReportGeneratePointService {
             }
         }
     }
+
+
+    public void handleQuestionPointAndAnalyze(Integer mpid){
+        //获取试卷基础信息
+        MsPaper paper = msPaperMapper.selectByPrimaryKey(mpid);
+        //先生产学生报告
+        if(paper.getPtype() == 1){
+            msPaperAnalyzeService.savePaperAnalyzeForQuestion(paper);
+        }else{
+            msPaperAnalyzeService.savePaperAnalyzeForFj(paper);
+        }
+
+        //删除试卷试题信息
+        msrSubjectPointMapper.deletePointAnalyze(paper.getExamid(),paper.getSubjectid());
+
+
+    }
 }

smarking/src/main/java/com/xhkjedu/smarking/service/report/report/MsrSubjectPointService.java

@@ -1,12 +1,14 @@
 package com.xhkjedu.smarking.service.report.report;
 
 import com.xhkjedu.smarking.mapper.exam.MsClassMapper;
+import com.xhkjedu.smarking.mapper.report.reportclass.MsrClassQuestionMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointRankgroupMapper;
 import com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointSectionMapper;
 import com.xhkjedu.smarking.model.exam.MsClass;
 import com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPoint;
 import com.xhkjedu.smarking.vo.report.reportother.ExamReportParams;
+import com.xhkjedu.utils.N_Utils;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
@@ -31,18 +33,68 @@ public class MsrSubjectPointService {
     private MsrSubjectPointSectionMapper msrSubjectPointSectionMapper;
     @Resource
     private MsClassMapper msClassMapper;
+    @Resource
+    private MsrClassQuestionMapper msrClassQuestionMapper;
 
-    //学科素养报告-标定知识点
-    public void listXksyQuestionPoints(ExamReportParams params){
-
+    //学科素养报告-标定知识点-试题知识点
+    public List<Map<String,Object>> listXksyQuestionPoints(ExamReportParams params){
+        //获取已标定试题知识点
+        return msrSubjectPointMapper.listQuestionPointsForXhsy(params);
     }
 
     //学科素养报告-知识点整体分析
     public Map<String,Object> listXksyPointZt(ExamReportParams params){
         //层级下所有知识点
         List<MsrSubjectPoint> points = msrSubjectPointMapper.listXksyPointsZt(params);
+        if(points.isEmpty()) return null;
+
         //获取全体学员的知识点
         List<MsrSubjectPoint> schoolPoints = points.stream().filter(p -> p.getClassid()==0).collect(Collectors.toList());
+        //根据全体的情况，做出分析诊断
+        //把知识点按照，满分排序
+        List<MsrSubjectPoint> fullScorePoints = schoolPoints.stream().sorted((p1,p2) -> p2.getFullscore().compareTo(p1.getFullscore())).collect(Collectors.toList());
+        //把知识点按照平均得分率排序
+        List<MsrSubjectPoint> avgRatePoints = schoolPoints.stream().sorted((p1,p2) -> p2.getAvgrate().compareTo(p1.getAvgrate())).collect(Collectors.toList());
+        String[] scoreFirst;
+        String[] scorelast;
+        String[] rateFrist;
+        String[] rateLast;
+        if(schoolPoints.size() >=4){
+            //前后各取两个
+            List<MsrSubjectPoint> firstScore = fullScorePoints.stream().limit(2).collect(Collectors.toList());
+            scoreFirst = new String[]{firstScore.get(0).getPointname(), firstScore.get(1).getPointname()};
+            List<MsrSubjectPoint> lastScore = fullScorePoints.stream().skip(fullScorePoints.size() - 2).collect(Collectors.toList());
+            scorelast = new String[]{lastScore.get(0).getPointname(), lastScore.get(1).getPointname()};
+
+            List<MsrSubjectPoint> firstRate = avgRatePoints.stream().limit(2).collect(Collectors.toList());
+            rateFrist = new String[]{firstRate.get(0).getPointname(), firstRate.get(1).getPointname()};
+            List<MsrSubjectPoint> lastRate = avgRatePoints.stream().skip(avgRatePoints.size() - 2).collect(Collectors.toList());
+            rateLast = new String[]{lastRate.get(0).getPointname(), lastRate.get(1).getPointname()};
+
+        }else if(fullScorePoints.size() <4 && avgRatePoints.size() >=2){
+            //前后各取1个
+            List<MsrSubjectPoint> firstScore = fullScorePoints.stream().limit(1).collect(Collectors.toList());
+            scoreFirst = new String[]{firstScore.get(0).getPointname()};
+            List<MsrSubjectPoint> lastScore = fullScorePoints.stream().skip(fullScorePoints.size() - 1).collect(Collectors.toList());
+            scorelast = new String[]{lastScore.get(0).getPointname()};
+
+            List<MsrSubjectPoint> firstRate = avgRatePoints.stream().limit(1).collect(Collectors.toList());
+            rateFrist = new String[]{firstRate.get(0).getPointname()};
+            List<MsrSubjectPoint> lastRate = avgRatePoints.stream().skip(avgRatePoints.size() - 1).collect(Collectors.toList());
+            rateLast = new String[]{lastRate.get(0).getPointname()};
+
+        }else{
+            //仅前获取一个
+            scoreFirst = new String[]{fullScorePoints.get(0).getPointname()};
+            scorelast = null;
+            rateFrist = new String[]{avgRatePoints.get(0).getPointname()};
+            rateLast = null;
+        }
+        Map<String,Object> zdjgMap = new HashMap<>();
+        zdjgMap.put("maxScore",scoreFirst);
+        zdjgMap.put("minScore",scorelast);
+        zdjgMap.put("maxRate",rateFrist);
+        zdjgMap.put("minRate",rateLast);
 
         //知识点结构平均得分率表格表头
         List<Map<String,Object>> pointTitles = schoolPoints.stream().map(p -> { Map<String,Object> map = new HashMap<>();
@@ -74,15 +126,77 @@ public class MsrSubjectPointService {
         }
 
         Map<String,Object> rtnMap = new HashMap<>();
-        rtnMap.put("schoolPoints",schoolPoints);
-        rtnMap.put("pointTitles",pointTitles);
-        rtnMap.put("pointClassList",pointClassList);
+        rtnMap.put("schoolPoints",schoolPoints);//全体知识点数据
+        rtnMap.put("zdjgMap",zdjgMap);//诊断结果
+        rtnMap.put("pointTitles",pointTitles);//平均得分率表格表头
+        rtnMap.put("pointClassList",pointClassList);//平均得分率数据
         return rtnMap;
     }
 
     //学科素养报告-单个知识点分析-知识点及知识点下试题
-    public void listXksyPointDg(ExamReportParams params){
+    public Map<Object,List<Map<String,Object>>> listXksyPointOneForPoints(ExamReportParams params){
+        //获取所有知识点，把知识点按层级分组
+        List<Map<String,Object>> points = msrSubjectPointMapper.listXksyPointsAll(params);
+        return points.stream().collect(Collectors.groupingBy(t -> t.get("pointlevel")));
+    }
+
+    //学科素养报告-单个知识点分析-知识点详情
+    public Map<String,Object> listXksyPointOneForPointDetail(ExamReportParams params){
+        //获取知识点点对应的试题数据
+        MsrSubjectPoint point = msrSubjectPointMapper.getXksyPointByPointid(params);
+        params.setMptqids(point.getMptqids());
+        //获取试题，试题详情图片暂未处理
+        List<Map<String,Object>> questions = msrClassQuestionMapper.listQuestionsForXksyOnePoint(params);
+        //结果图，把知识点情况取出
+        Map<String,Object> pointMap = new HashMap<>();
+        pointMap.put("spid",point.getSpid());
+        pointMap.put("fullscore",point.getFullscore());
+        pointMap.put("schoolavgscore",point.getAvgscore());
+        pointMap.put("schoolavgrate",point.getAvgrate());
+        pointMap.put("mfnum",point.getMfnum());
+        pointMap.put("lfnum",point.getLfnum());
+        questions.add(0,pointMap);
 
+        //知识点与总分的相关性曲线
+        List<Map<String,Object>> pointSections = msrSubjectPointSectionMapper.listXhsySections(params);
+        //知识点考生分组分析
+        List<Map<String,Object>> rankgroups = msrSubjectPointRankgroupMapper.listXksyPointOneRankgroup(params);
+        //表格头部信息
+        List<Object> groupRankTitles = rankgroups.stream().filter(r ->N_Utils.isEmpty(r.get("rsection"))).map(r -> r.get("rgroup")).distinct().collect(Collectors.toList());
+        List<Object> rsections = rankgroups.stream().map(m -> m.get("rsection")).distinct().collect(Collectors.toList());
+        //分组分数分布表
+        List<Map<String,Object>> groupRankList = new ArrayList<>();
+        for(Object rsection : rsections){
+            if(N_Utils.isNotEmpty(rsection)){
+                List<Map<String,Object>> rsectionList = rankgroups.stream().filter(m -> m.get("rsection").equals(rsection)).collect(Collectors.toList());
+                Map<String,Object> rsMap = new HashMap<>();
+                rsMap.put("rsection",rsection);
+                rsMap.put("groupranks",rsectionList);
+                groupRankList.add(rsMap);
+            }else{
+                List<Map<String,Object>> rsectionList = rankgroups.stream().filter(m -> N_Utils.isEmpty(m.get("rsection"))).collect(Collectors.toList());
+                Map<String,Object> rsMap = new HashMap<>();
+                rsMap.put("rsection","合计");
+                rsMap.put("groupranks",rsectionList);
+                groupRankList.add(rsMap);
+
+                Map<String,Object> dflMap = new HashMap<>();
+                dflMap.put("rsection","得分率");
+                dflMap.put("groupranks",rsectionList);
+                groupRankList.add(dflMap);
+            }
+        }
+        //各班知识点对比
+        List<Map<String,Object>> classPointList = msrSubjectPointMapper.listXksyPointsForAllClass(params);
+
+        //返回试题基础信息
+        Map<String,Object> rtnMap = new HashMap<>();
+        rtnMap.put("questions",questions);//知识点下试题
+        rtnMap.put("pointSections",pointSections);//知识点与总分的相关性
+        rtnMap.put("groupRankTitles",groupRankTitles);//分组分数分布-表头
+        rtnMap.put("groupRankList",groupRankList);//分组分数分布-数据
+        rtnMap.put("classPointList",classPointList);//各班知识点对比
+        return rtnMap;
     }
 
 }

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

@@ -786,10 +786,10 @@ public class MarkingUtil {
     }
 
     public static void main(String[] args) {
-        List<String> options = Arrays.asList("A","B","D","F","","C","E");
-        List<String> newOptions = options.stream().map(s -> s != null && !s.isEmpty() ? s : "未作答").sorted().collect(Collectors.toList());
-        for (String option : newOptions) {
-            System.out.println(option);
-        }
+       List<RankGroupVo> list = fdScore(1.0,5);
+       for (RankGroupVo rgvo : list) {
+           System.out.println(rgvo.getGroupname() + ";" + rgvo.getMinvalue() + "-" + rgvo.getMaxvalue());
+
+       }
     }
 }

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

@@ -31,4 +31,10 @@ public class ExamReportParams {
     private Integer rgtype;//客观题选项 2客/主分值
 
     private Integer pointlevel;//1一级知识点2二级知识点3三级知识点
+
+    private String pointid;//知识点ID
+
+    private String mptqids;//多个试题id
+
+    private Integer spid;//id
 }

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

@@ -4,7 +4,7 @@
 
     <!--根据msid查询试卷模板列表-->
     <select id="listTemplatesByMpid" resultType="java.util.Map">
-        select t.mtid,t.mpid,t.currstep,t.tstate,t.createtime,t.tfront,t.tback from ms_template t
+        select t.mtid,t.mpid,t.currstep,t.tstate,t.createtime,t.tfront,t.tback,t.blankindex,t.anglefront,t.angleback from ms_template t
         left join ms_paper p on t.mpid=p.mpid
         where p.mpid=#{mpid} order by t.createtime desc
     </select>

smarking/src/main/resources/mapper/report/reportclass/MsrClassQuestionMapper.xml

@@ -130,6 +130,15 @@
         and cq.subjectid=#{param.subjectid} and cq.classid=0 and cq.mptqid=#{param.mptqid}
     </select>
 
+    <!--学科素养-单个知识点分析-知识点下试题-->
+    <select id="listQuestionsForXksyOnePoint" resultType="java.util.Map">
+        select distinct cq.cqid,cq.mptqid,cq.qn,cq.fullscore,cq.schoolavgscore,cq.schoolavgrate,cq.mfnum,
+                        cq.lfnum,cq.qtype,q.stemcoor,q.quecoor
+        from msr_class_question cq left join ms_paper_qtype_question q on cq.mptqid=q.mptqid
+        where cq.examid=#{param.examid} and cq.subjectid=#{param.subjectid} and cq.classid=0
+        and cq.mptqid in (${param.mptqids}) order by cq.cqid
+    </select>
+
 
 
 </mapper>

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectPointMapper.xml

@@ -9,9 +9,62 @@
         and p.schoolid=(select schoolid from ms_exam where examid=#{examid} limit 1))) order by p.pointlevel,p.pointorder
     </select>
 
+    <!--学科素养-标定知识点-试题知识点-->
+    <resultMap id="questionPoints" type="java.util.Map">
+        <result property="mptqid" column="mptqid"/>
+        <result property="fullscore" column="fullscore"/>
+        <result property="schoolavgscore" column="schoolavgscore"/>
+        <result property="schoolavgrate" column="schoolavgrate"/>
+        <result property="questionid" column="questionid"/>
+        <result property="questionpid" column="questionpid"/>
+        <collection property="points" ofType="java.util.Map" javaType="java.util.ArrayList">
+            <result property="pointid" column="pointid"/>
+            <result property="pointname" column="pointname"/>
+            <result property="mpid" column="mpid"/>
+        </collection>
+    </resultMap>
+    <select id="listQuestionPointsForXhsy" resultMap="questionPoints">
+        select distinct cq.mptqid,cq.fullscore,cq.schoolavgscore,cq.schoolavgrate,q.questionid,
+        q.questionpid,qp.pointid,qp.pointname,qp.mpid
+        from msr_class_question cq
+        left join ms_paper_qtype_question q on cq.mptqid=q.mptqid
+        left join ms_paper_qtype_question_point qp on cq.mptqid=qp.mptqid
+        where cq.examid=#{param.examid} and cq.subjectid=#{param.subjectid} and cq.classid=0 order by cq.qorder
+    </select>
+
     <!--学科素养-知识点整体分析-级别下知识点-->
     <select id="listXksyPointsZt" resultType="com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPoint">
         select * from msr_subject_point where examid=#{param.examid} and subjectid=#{param.subjectid} and pointlevel=#{param.pointlevel} order by spid
     </select>
 
+    <!--学科素养-单个知识点分析-所有知识点-->
+    <select id="listXksyPointsAll" resultType="java.util.Map">
+        select spid,pointid,pointname,pointlevel from msr_subject_point
+        where examid=#{param.examid} and subjectid=#{param.subjectid} and classid=0 order by pointlevel,spid
+    </select>
+
+    <!--学科素养-单个知识点分析-知识点详情-->
+    <select id="getXksyPointByPointid" resultType="com.xhkjedu.smarking.model.report.reportsubject.MsrSubjectPoint">
+        select spid,fullscore,avgscore,avgrate,mptqids,mfnum,lfnum from msr_subject_point where examid=#{param.examid} and subjectid=#{param.subjectid} and classid=0
+        and pointlevel=#{param.pointlevel} and pointid=#{param.pointid} limit 1
+    </select>
+
+    <!--学科素养-单个知识点分析-各班知识点对比-->
+    <select id="listXksyPointsForAllClass" resultType="java.util.Map">
+        select p.classid,p.fullscore,p.maxscore,p.minscore,p.avgscore,p.avgrate,
+        p.bzc,p.cyxs,c.classname from msr_subject_point p
+        left join ms_class c on p.examid=c.examid and p.subjectid=c.subjectid and p.classid=c.classid
+        where p.examid=#{param.examid} and p.subjectid=#{param.subjectid} and p.pointid=#{param.pointid} and p.pointlevel=#{param.pointlevel}
+        order by p.spid
+    </select>
+
+    <!--删除知识点相关报告-->
+    <delete id="deletePointAnalyze">
+        delete from msr_student_point where examid = #{examid} and subjectid=#{subjectid};
+        delete from msr_subject_point where examid = #{examid} and subjectid=#{subjectid};
+        delete from msr_subject_point_section where examid = #{examid} and subjectid=#{subjectid};
+        delete from msr_subject_question_rankgroup where examid = #{examid} and subjectid=#{subjectid};
+        delete from msr_subject_question_section where examid = #{examid} and subjectid=#{subjectid};
+    </delete>
+
 </mapper>

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectPointRankgroupMapper.xml

@@ -1,4 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointRankgroupMapper">
+
+    <!--学科素养-单个知识点分析-知识点考试分组分析-->
+    <select id="listXksyPointOneRankgroup" resultType="java.util.Map">
+        select spgid,rgroup,rsection,stunum,stuids from msr_subject_point_rankgroup where examid=#{param.examid}
+            and subjectid=#{param.subjectid}  and pointlevel=#{param.pointlevel} and pointid=#{param.pointid} order by spgid
+    </select>
 </mapper>

smarking/src/main/resources/mapper/report/reportsubject/MsrSubjectPointSectionMapper.xml

@@ -1,4 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 <mapper namespace="com.xhkjedu.smarking.mapper.report.reportsubject.MsrSubjectPointSectionMapper">
+
+    <!--学科素养-单个知识点分析-知识点与总分的相关性曲线-->
+    <select id="listXhsySections" resultType="java.util.Map">
+        select fdfw,avgscore,avgrate from msr_subject_point_section where subjectid = #{param.subjectid} and
+        examid=#{param.examid} and pointid=#{param.pointid} and pointlevel = #{param.pointlevel} order by spsid
+    </select>
 </mapper>