网关配置请求超时时间

重新生成试卷分析

gateway/src/main/java/com/xhkjedu/gateway/config/ConfigKey.java

@@ -0,0 +1,20 @@
+package com.xhkjedu.gateway.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description  读取配置文件类
+ * @Date 2022/10/17 14:26
+ **/
+@Component
+public class ConfigKey {
+
+    public static Integer rqovertime;
+
+    @Value("${rq.overtime}")
+    public void setRqovertime(Integer rqovertime) {
+        ConfigKey.rqovertime = rqovertime;
+    }
+
+}

gateway/src/main/java/com/xhkjedu/gateway/config/CustomizeCircuitBreakerConfig.java

@@ -35,7 +35,7 @@ public class CustomizeCircuitBreakerConfig {
 
         return factory -> factory.configureDefault(id -> new Resilience4JConfigBuilder(id)
                 //超时规则,设置为20s
-                .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofMillis(20000)).build())
+                .timeLimiterConfig(TimeLimiterConfig.custom().timeoutDuration(Duration.ofMillis(ConfigKey.rqovertime)).build())
                 //设置断路器配置
                 .circuitBreakerConfig(circuitBreakerConfig).build());
 

gateway/src/main/resources/application.properties

@@ -50,3 +50,6 @@ spring.cloud.gateway.routes[5].filters[1].args.fallbackUri=forward:/fallback
 eureka.client.service-url.defaultZone=http://localhost:8081/eureka/
 #设置eureka输出日志级别
 logging.level.com.netflix=error
+
+#请求超时时间30s
+rq.overtime = 30000

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

@@ -565,7 +565,7 @@ public class EPaperQtypeService {
         //保存之前先清除之前的试卷分析
         ePaperAnalyzeMapper.deleteByEpid(ePaper.getEpid());
         //总体分析（主观题、客观题）
-        //处理题型1单选题2多选题3主观题4判断对错5判断√×6判断TF7完形填空8阅读理解10任务型阅读11综合题12听力
+        //处理题型1单选题2多选题3主观题4判断对错5判断√×6判断TF11综合题12听力13填空题
         int znum = 0;
         double zscore = 0;
         int knum = 0;

sstudy/src/main/java/com/xhkjedu/sstudy/mapper/paper/PaperQtypeMapper.java

@@ -2,7 +2,14 @@ package com.xhkjedu.sstudy.mapper.paper;
 
 import com.xhkjedu.sstudy.base.TkMapper;
 import com.xhkjedu.sstudy.model.paper.TPaperQtype;
+import com.xhkjedu.sstudy.vo.paper.PaperQtypeVo;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 public interface PaperQtypeMapper extends TkMapper<TPaperQtype> {
     Integer deleteByPaperid(Integer paperid);
+
+    //试卷中试题
+    List<PaperQtypeVo> listPaperQtypeQuestions(@Param("paperid")Integer paperid);
 }

sstudy/src/main/java/com/xhkjedu/sstudy/model/paper/TPaperAnalyze.java

@@ -16,9 +16,6 @@ public class TPaperAnalyze extends BaseBean {
     //作业id
     private Integer paperid;
 
-    //学校id
-    private Integer schoolid;
-
     //难易度json
     private String complexityjson;
 
@@ -27,4 +24,10 @@ public class TPaperAnalyze extends BaseBean {
 
     //知识点分布json
     private String pointjson;
+
+    //总体分析：主观题+客观题
+    private String alljson;
+
+    //试题知识点占分
+    private String quespointjson;
 }

sstudy/src/main/java/com/xhkjedu/sstudy/model/paper/TPaperQtypeQuestion.java

@@ -44,7 +44,7 @@ public class TPaperQtypeQuestion extends BaseBean {
     private String questionpid;
 
     //复合题母题分值
-    private double mscore;
+    private Double mscore;
 
     //母题题型id
     private String mqtypeid;

sstudy/src/main/java/com/xhkjedu/sstudy/service/paper/PaperService.java

@@ -8,6 +8,7 @@ import com.xhkjedu.sstudy.mapper.paper.*;
 import com.xhkjedu.sstudy.mapper.paperstudent.PaperStudentMapper;
 import com.xhkjedu.sstudy.model.paper.*;
 import com.xhkjedu.sstudy.model.paperstudent.TPaperStudent;
+import com.xhkjedu.sstudy.utils.StudyUtil;
 import com.xhkjedu.sstudy.vo.paper.*;
 import com.xhkjedu.sstudy.vo.paperstudent.PaperSearchVo;
 import com.xhkjedu.sstudy.vo.question.QuestionVo;
@@ -88,7 +89,7 @@ public class PaperService {
                 //保存答题卡信息
                 savePaperScantronQtype(paper,qtypes);
                 //保存分析
-                //savePaperScantronAnalyze(paperid,paper.getSchoolid());
+                savePaperScantronAnalyze(paper,qtypes,scanlist);
             }
 
         }catch (Exception e){
@@ -138,8 +139,7 @@ public class PaperService {
                 paperScantronQtypeMapper.deleteByPaperid(paper.getPaperid());   //保存答题卡信息
                 savePaperScantronQtype(paper, qtypes);
                 //删除分析信息
-                //paperAnalyzeMapper.deleteByPaperid(paper.getPaperid());
-                //savePaperScantronAnalyze(paper.getPaperid(), paper.getSchoolid());  //保存分析
+                savePaperScantronAnalyze(paper,qtypes,scanlist);  //保存分析
 
                 rtn = true;
             }
@@ -151,8 +151,6 @@ public class PaperService {
         return rtn;
     }
 
-
-
     /**
      * 保存作业
      * @Param [paper]
@@ -219,14 +217,94 @@ public class PaperService {
     }
 
     //保存答题卡分析
-    private Integer savePaperScantronAnalyze(Integer paperid,Integer schoolid){
-        List<Map<String, Object>> list = paperScantronMapper.listQtypeAnalyze(paperid);
+    private Integer savePaperScantronAnalyze(TPaper paper,List<TPaperScantronQtype> qtypes,List<TPaperScantron> scanlist){
+        int znum = 0;
+        double zscore = 0;
+        int knum = 0;
+        double kscore = 0;
+        for(TPaperScantron q : scanlist){
+            if(N_Utils.isObjectiveQuestion(q.getCtype())){
+                knum ++;
+                kscore = kscore + q.getPsscore();
+            }else{
+                znum ++;
+                zscore = zscore + q.getPsscore();
+            }
+        }
+
+        double znumrate = N_Utils.getIntegerDivideAndMulitiply(znum, paper.getPapernum());
+        double knumrate = N_Utils.getDoubleReduce(100.0, znumrate);
+
+        double zscorerate = N_Utils.getDoubleDivideAndMulitiply(zscore, paper.getPapernum());
+        double kscorerate = N_Utils.getDoubleReduce(100.0,zscorerate);
+
+        List<Map> ranglist = new ArrayList<>();
+        Map 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 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 ztmap = new TreeMap<>();
+        ztmap.put("pnum", paper.getPapernum());
+        ztmap.put("pscore",paper.getPaperscore());
+        ztmap.put("ranglist",ranglist);
+
+        //题型分布(按照名称进行分组)
+        qtypes.stream().sorted(Comparator.comparing(TPaperScantronQtype::getPstorder)).collect(Collectors.toList());
+        Map<String,List<TPaperScantronQtype>> qtypemap =  qtypes.stream().collect(Collectors.groupingBy(TPaperScantronQtype:: getQtypename, Collectors.toList()));
+        List<Map> qtlist = new ArrayList<>();
+        for(Map.Entry<String, List<TPaperScantronQtype>> entry : qtypemap.entrySet()){
+            List<TPaperScantronQtype> aq = entry.getValue();
+            int num = aq.stream().mapToInt(TPaperScantronQtype::getPstnum).sum();
+            double tscore = aq.stream().collect(Collectors.summingDouble(TPaperScantronQtype:: getPstscore));
+            double storerate = N_Utils.getDoubleDivideAndMulitiply(tscore, paper.getPaperscore());
+            //获取小题题号
+            List<Integer> orderlist = new ArrayList<>();
+            List<Integer> eptqidlist = new ArrayList<>();
+            List<Double> scorelist = new ArrayList<>();
+            List<String> qnamelist = new ArrayList<>();
+            for(TPaperScantronQtype t : aq){
+                List<TPaperScantron> qlist = t.getScantrons();
+                for(TPaperScantron q : qlist){
+                    orderlist.add(q.getPsorder());
+                    eptqidlist.add(q.getId());
+                    scorelist.add(q.getPsscore());
+                    qnamelist.add(q.getQtypename());
+                }
+            }
+
+            Map anmap = new TreeMap();//题型对应试题的id和基础信息
+            anmap.put("orders",orderlist);
+            anmap.put("eptqids",eptqidlist);
+            anmap.put("scores",scorelist);
+            anmap.put("qtypenames",qnamelist);
+
+            Map tmap = new TreeMap();
+            tmap.put("qtname",entry.getKey());
+            tmap.put("qtid",aq.get(0).getPsqtypeid());
+            tmap.put("num",num);
+            tmap.put("score",tscore);
+            tmap.put("srate",storerate);
+            tmap.put("ques",anmap);
+            qtlist.add(tmap);
+        }
 
         TPaperAnalyze paperAnalyze = new TPaperAnalyze();
-        paperAnalyze.setPaperid(paperid);
-        paperAnalyze.setQtypejson(JSON.toJSONString(list));
+        paperAnalyze.setPaperid(paper.getPaperid());
+        paperAnalyze.setQtypejson(JSON.toJSONString(qtlist));
+        paperAnalyze.setAlljson(JSON.toJSONString(ztmap));
 
-        paperAnalyze.setSchoolid(schoolid);
+        paperAnalyzeMapper.deleteByPaperid(paper.getPaperid());//先删除原分析
         paperAnalyzeMapper.insertUseGeneratedKeys(paperAnalyze);
         return paperAnalyze.getId();
     }
@@ -271,7 +349,7 @@ public class PaperService {
             paperid = savePaper(paper);//保存作业
             paper.setPaperid(paperid);
             savePaperQtype(paper, qtypes);//保存作业题型信息
-            //generatePaperAnalyze(paperid, paper.getSchoolid());//生成作业分析
+            generatePaperAnalyze(paper);//生成作业分析
         }catch (Exception e){
             log.error("保存结构性试题作业失败：" + e.getMessage());
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -402,23 +480,364 @@ public class PaperService {
      * @Date 2020/6/10 9:57
      * @return java.lang.Integer
      **/
-    private Integer generatePaperAnalyze(Integer paperid, Integer schoolid) {
-        //1.题型统计
-        List<Map<String, Object>> rateList = paperQtypeQuestionMapper.paperTypeAnalyze(paperid);
-        //2.难易度统计
-        List<Map<String, Object>> complexityRateList = paperQtypeQuestionMapper.complexityRateAnalyze(paperid);
-        //3.知识点统计
-        List<Map<String, Object>> pointRateList = paperQtypeQuestionMapper.pointRateAnalyze(paperid);
+    private Integer generatePaperAnalyze(TPaper paper) {
+        //获取是试卷试题
+        List<PaperQtypeVo> qtypelist = paperQtypeMapper.listPaperQtypeQuestions(paper.getPaperid());
+        List<QuestionOrderVo> pointqlist = new ArrayList<>();//用于存放知识点，以及知识点下得分
+        List<PaperQtypeQuesVo> mquestions = new ArrayList<>();//存放单题和母题
+        List<QuestionOrderVo> complexitylist = new ArrayList<>();//试题难易度存放试题
+        List<QuestionPointVo> quesplist = new ArrayList<>();//单题、母题对应知识点
+
+        //处理出试卷中所有试题、知识点
+        List<Map> typelist = new ArrayList<>();//题型分析
+        for(PaperQtypeVo qt : qtypelist){
+            List<Integer> qorderlist = new ArrayList<>();
+            List<QuestionOrderVo> qtypeqlist = new ArrayList<>();
+            List<PaperQtypeQuesVo> tqlist = qt.getQuelist();
+            int hasmt = 0;
+            for(PaperQtypeQuesVo 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> qpoints = q.getPoints();
+                    //处理试题知识点占分
+                    setPaperQuestionPointScore(pointqlist,quesplist,qpoints,q,null,null);
+                    setPaperQuestionQtypeScore(qtypeqlist,q,null,null);//处理试题题型
+                    setPaperQuestionComplexityScore(complexitylist,q,null,null);//处理试题难易度
+                }
+                if(q.getQlevel() == 3){
+                    hasmt ++;
+                }
+                if(!qorderlist.contains(q.getPtqorder())){
+                    qorderlist.add(q.getPtqorder());
+                }
+            }
+
+            if(hasmt > 0){
+                //说明该题型下有复合题,复合体进行知识点、题型下试题题号及id进行操作
+                Map<String,List<PaperQtypeQuesVo>> quesMap = tqlist.stream().collect(Collectors.groupingBy(PaperQtypeQuesVo:: getQuestionpid, Collectors.toList()));
+                for(Map.Entry<String, List<PaperQtypeQuesVo>> entry : quesMap.entrySet()){
+                    if(!entry.getKey().equals("000")){
+                        //说明该题为母题，
+                        PaperQtypeQuesVo mq = new PaperQtypeQuesVo();
+                        List<PaperQtypeQuesVo> sonques = entry.getValue();
+                        int k = 0;//如果k大于1说明有小题是主观题，则母题为主观题
+                        double score = 0;
+                        for(PaperQtypeQuesVo sq : sonques){
+                            if(!N_Utils.isObjectiveQuestion(sq.getCtype())){
+                                k++;
+                            }
+                            score = N_Utils.getDoubleSum(score,sq.getPtqscore());
+                        }
+
+                        PaperQtypeQuesVo qobj = sonques.get(0);
+                        mq.setQuestionid(qobj.getQuestionpid());
+                        mq.setComplexity(qobj.getMcomplexity());
+                        mq.setPtqorder(qobj.getPtqorder());
+                        mq.setPtqscore(score);
+                        mq.setQtypename(qobj.getMqtypename());
+                        if(k == 0){
+                            mq.setMctype(111);
+                        }else{
+                            mq.setMctype(112);
+                        }
+                        mq.setQlevel(qobj.getMqlevel());
+                        mq.setSonques(sonques);
+                        //获取所有子题的试题题号
+                        List<String> qns = sonques.stream().map(PaperQtypeQuesVo::getQn).collect(Collectors.toList());
+                        String[] qnstr = qns.stream().toArray(String[]::new);
+                        //所有子题的试题eptqid
+                        List<Integer> eptqids = sonques.stream().map(PaperQtypeQuesVo::getPtqid).collect(Collectors.toList());
+                        Integer[] eptqidstr = eptqids.stream().toArray(Integer[]::new);
+
+                        //获取知识点
+                        List<Map> qpoints = sonques.get(0).getPoints();
+                        mq.setPoints(qpoints);
+                        mquestions.add(mq);
+                        setPaperQuestionPointScore(pointqlist,quesplist,qpoints,mq,qnstr,eptqids);
+                        setPaperQuestionQtypeScore(qtypeqlist,mq,qnstr,eptqidstr);//处理试题题型
+                        setPaperQuestionComplexityScore(complexitylist,mq,qnstr,eptqidstr);//处理试题难易度
+                    }
+                }
+            }
+
+            //试题题型分析数据
+            double storerate = N_Utils.getDoubleDivideAndMulitiply(qt.getPtscore(), paper.getPaperscore());
+            Map tmap = new TreeMap();
+            tmap.put("qtid",qt.getPtid());
+            tmap.put("qtname",qt.getQtypename());
+            tmap.put("num",qt.getPtnum());
+            tmap.put("score",qt.getPtscore());
+            tmap.put("srate",storerate);
+            qtypeqlist = qtypeqlist.stream().sorted(Comparator.comparing(QuestionOrderVo::getOrder)).collect(Collectors.toList());
+            tmap.put("ques",qtypeqlist);
+            typelist.add(tmap);
+        }
+
+        //试题总体分布进行分析
+        //客观题集合
+        List<PaperQtypeQuesVo> ktlst = mquestions.stream().filter(q->q.getMctype() == 111).collect(Collectors.toList());
+        int ktnum = ktlst.size();
+        double ktscore = ktlst.stream().collect(Collectors.summingDouble(PaperQtypeQuesVo:: getPtqscore));
+        double ktnrate = N_Utils.getIntegerDivideAndMulitiply(ktnum, paper.getPapernum());
+        double ktsrate = N_Utils.getDoubleDivideAndMulitiply(ktscore, paper.getPaperstate());
+        List<PaperQsVo> ranglist = new ArrayList<>();
+        ranglist.add(new PaperQsVo("客观题", ktscore, ktnum, ktsrate, ktnrate));
+        PaperQsVo zgq = new PaperQsVo();
+        zgq.setQtname("主观题");
+        zgq.setNum(paper.getPapernum() - ktnum);
+        zgq.setNrate(N_Utils.getDoubleReduce(100.0,ktnrate));
+        zgq.setScore(N_Utils.getDoubleReduce(paper.getPaperscore(),ktscore));
+        zgq.setSrate(N_Utils.getDoubleReduce(100.0,ktsrate));
+        ranglist.add(zgq);
+        Map ztmap = new TreeMap<>();
+        ztmap.put("pnum", paper.getPapernum());
+        ztmap.put("pscore",paper.getPaperscore());
+        ztmap.put("ranglist",ranglist);
+
+        //难易度
+        List<Map> 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(s -> s.getScore()).sum();
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score,paper.getPaperscore());
+                Map 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);
+            }
+        }
+
+        //知识点分析
+        List<Map> pointlist = new ArrayList<>();
+        if(N_Utils.isListNotEmpty(pointqlist)){
+            Map<String,List<QuestionOrderVo>> pointmap = pointqlist.stream().collect(Collectors.groupingBy(QuestionOrderVo::getId,Collectors.toList()));
+            //根据指示进行分组，
+            for(Map.Entry<String, List<QuestionOrderVo>> entry : pointmap.entrySet()){
+                List<QuestionOrderVo> pgblist = entry.getValue();
+                //获取知识点的总分
+                Double score = pgblist.stream().mapToDouble(s -> s.getScore()).sum();
+                Double srate = N_Utils.getDoubleDivideAndMulitiply(score,paper.getPaperscore());
+                Map prate = new TreeMap();
+                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);
+            }
+        }
+
         TPaperAnalyze paperAnalyze = new TPaperAnalyze();
-        paperAnalyze.setPaperid(paperid);
-        paperAnalyze.setQtypejson(JSON.toJSONString(rateList));
-        paperAnalyze.setComplexityjson(JSON.toJSONString(complexityRateList));
-        paperAnalyze.setPointjson(JSON.toJSONString(pointRateList));
-        paperAnalyze.setSchoolid(schoolid);
+        paperAnalyze.setPaperid(paper.getPaperid());
+        paperAnalyze.setAlljson(JSON.toJSONString(ztmap));//总体分析
+        paperAnalyze.setQtypejson(JSON.toJSONString(typelist));//试题栏题型分析
+        paperAnalyze.setComplexityjson(JSON.toJSONString(clist));//难易度分析
+        paperAnalyze.setPointjson(JSON.toJSONString(pointlist));//知识点分析
+        paperAnalyze.setQuespointjson(JSON.toJSONString(quesplist));
+
+        paperAnalyzeMapper.deleteByPaperid(paper.getPaperid());
         paperAnalyzeMapper.insertUseGeneratedKeys(paperAnalyze);
         return paperAnalyze.getId();
     }
 
+    //设置知识点
+    private void setPaperQuestionPointScore(List<QuestionOrderVo> pointqlist,List<QuestionPointVo> quesplist,List<Map> qpoints,PaperQtypeQuesVo dq,String[] qnstr,List<Integer> eptqids){
+        if(N_Utils.isListNotEmpty(qpoints)){
+            if(qpoints.size() == 1){
+                //试题只有一个知识点
+                Map pointmap = qpoints.get(0);
+                QuestionOrderVo qpoint = new QuestionOrderVo();
+                qpoint.setId(pointmap.get("pointid").toString());
+                qpoint.setName(pointmap.get("pointname").toString());
+                qpoint.setOrder(dq.getPtqorder());
+                qpoint.setScore(dq.getPtqscore());
+                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(eptqids)){
+                    qpoint.setPtqids(new Integer[]{dq.getPtqid()});
+                }else{
+                    Integer[] eptqidstr = eptqids.stream().toArray(Integer[]::new);
+                    qpoint.setPtqids(eptqidstr);
+                }
+                pointqlist.add(qpoint);
+
+                //试题对应知识点
+                QuestionPointVo questionPointVo = new QuestionPointVo();
+                questionPointVo.setOrder(dq.getPtqorder());
+                questionPointVo.setScore(dq.getPtqscore());
+                questionPointVo.setQlevel(dq.getQlevel());
+                questionPointVo.setQuestionid(dq.getQuestionid());
+                List<Map> pointids = new ArrayList<>();
+                Map map = new HashMap();
+                map.put("pointid",pointmap.get("pointid").toString());
+                map.put("score",dq.getPtqscore());
+                pointids.add(map);
+                questionPointVo.setPointids(pointids);
+
+                if(N_Utils.isListEmpty(eptqids)){
+                    List<Integer> saveids = new ArrayList<>();
+                    saveids.add(dq.getPtqid());
+                    questionPointVo.setPtqids(saveids);
+                    questionPointVo.setPtqid(dq.getPtqid());
+                }else{
+                    questionPointVo.setPtqids(eptqids);
+                    questionPointVo.setPtqid(0);
+                }
+                quesplist.add(questionPointVo);
+            }else{
+
+                //试题有多个知识点
+                //计算每个知识点所占分值（平均分配）
+                Double[] avgps = StudyUtil.getPointAvgScore(qpoints.size(), dq.getPtqscore());
+                List<Map> pointids = new ArrayList<>();
+                for(int m = 0; m<qpoints.size();m++){
+                    Map pointmap = qpoints.get(m);
+                    QuestionOrderVo qpoint = new QuestionOrderVo();
+                    qpoint.setId(pointmap.get("pointid").toString());
+                    qpoint.setName(pointmap.get("pointname").toString());
+                    qpoint.setOrder(dq.getPtqorder());
+                    qpoint.setQlevel(dq.getQlevel());
+                    qpoint.setQuestionid(dq.getQuestionid());
+
+
+                    Map 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(eptqids)){
+                        qpoint.setPtqids(new Integer[]{dq.getPtqid()});
+                    }else{
+                        Integer[] eptqidstr = eptqids.stream().toArray(Integer[]::new);
+                        qpoint.setPtqids(eptqidstr);
+                    }
+                    pointqlist.add(qpoint);
+                }
+
+                //试题对应知识点
+                QuestionPointVo questionPointVo = new QuestionPointVo();
+                questionPointVo.setOrder(dq.getPtqorder());
+                questionPointVo.setScore(dq.getPtqscore());
+                questionPointVo.setQlevel(dq.getQlevel());
+                questionPointVo.setQuestionid(dq.getQuestionid());
+                questionPointVo.setPointids(pointids);
+                if(N_Utils.isListEmpty(eptqids)){
+                    List<Integer> saveids = new ArrayList<>();
+                    saveids.add(dq.getPtqid());
+                    questionPointVo.setPtqids(saveids);
+                    questionPointVo.setPtqid(dq.getPtqid());
+
+                }else{
+                    questionPointVo.setPtqids(eptqids);
+                    questionPointVo.setPtqid(0);
+                }
+                quesplist.add(questionPointVo);
+
+            }
+        } else{
+            QuestionPointVo questionPointVo = new QuestionPointVo();
+            questionPointVo.setOrder(dq.getPtqorder());
+            questionPointVo.setScore(dq.getPtqscore());
+            questionPointVo.setQlevel(dq.getQlevel());
+            questionPointVo.setQuestionid(dq.getQuestionid());
+            questionPointVo.setPointids(null);
+            if(N_Utils.isListEmpty(eptqids)){
+                List<Integer> saveids = new ArrayList<>();
+                saveids.add(dq.getPtqid());
+                questionPointVo.setPtqids(saveids);
+                questionPointVo.setPtqid(dq.getPtqid());
+            }else{
+                questionPointVo.setPtqids(eptqids);
+                questionPointVo.setPtqid(0);
+            }
+
+            quesplist.add(questionPointVo);
+        }
+    }
+
+    //设置题型下试题题号及分值
+    private void setPaperQuestionQtypeScore(List<QuestionOrderVo> qtypelist,PaperQtypeQuesVo dq,String[] qnstr,Integer[] eptqidstr){
+        QuestionOrderVo qtype = new QuestionOrderVo();
+        qtype.setId(dq.getQtypeid());
+        qtype.setName(dq.getQtypename());
+        qtype.setComplexity(dq.getComplexity());
+        qtype.setOrder(dq.getPtqorder());
+        qtype.setScore(dq.getPtqscore());
+        qtype.setQlevel(dq.getQlevel());
+        qtype.setQuestionid(dq.getQuestionid());
+        if(qnstr == null){
+            qtype.setQns(new String[]{dq.getQn()});
+        }else{
+            qtype.setQns(qnstr);
+        }
+        if(eptqidstr == null){
+            qtype.setPtqids(new Integer[]{dq.getPtqid()});
+        }else{
+            qtype.setPtqids(eptqidstr);
+        }
+
+        qtypelist.add(qtype);
+    }
+
+    //设置试题难易度
+    private void setPaperQuestionComplexityScore(List<QuestionOrderVo> complexityList,PaperQtypeQuesVo dq,String[] qnstr,Integer[] eptqidstr){
+        QuestionOrderVo qtype = new QuestionOrderVo();
+        qtype.setId(dq.getComplexity().toString());//存放试题难易度
+        qtype.setOrder(dq.getPtqorder());
+        qtype.setScore(dq.getPtqscore());
+        qtype.setQlevel(dq.getQlevel());
+        qtype.setQuestionid(dq.getQuestionid());
+        if(qnstr == null){
+            qtype.setQns(new String[]{dq.getQn()});
+        }else{
+            qtype.setQns(qnstr);
+        }
+        if(eptqidstr == null){
+            qtype.setPtqids(new Integer[]{dq.getPtqid()});
+        }else{
+            qtype.setPtqids(eptqidstr);
+        }
+
+        complexityList.add(qtype);
+    }
+
     /**
      *功能描述  详情--答题卡
      * @author WN

sstudy/src/main/java/com/xhkjedu/sstudy/utils/StudyUtil.java

@@ -14,6 +14,7 @@ import org.springframework.util.MultiValueMap;
 import org.springframework.web.client.RestClientException;
 import org.springframework.web.client.RestTemplate;
 
+import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -110,4 +111,28 @@ public class StudyUtil {
         }
         return types;
     }
+
+    /**
+     * @Description 分值平均后得到的值，如果整除返回数组元素1，未整除返回元素数量2
+     * @Param [num, score] 数量，分值
+     * @Return java.lang.Double[] 第一个未平均分值，第二个值为最后一个数的分值
+     * @Author wn
+     * @Date 2022/8/18 11:07
+     **/
+    public static Double[] getPointAvgScore(int num, Double score) {
+        BigDecimal bScore = new BigDecimal(Double.toString(score));
+        BigDecimal bNum = new BigDecimal(Integer.toString(num));
+
+        BigDecimal avg = bScore.divide(bNum, 1, BigDecimal.ROUND_DOWN);
+        BigDecimal avgAllScore = avg.multiply(bNum);//平均分乘以数量得到的分值
+        if (bScore.equals(avgAllScore)) {
+            //说明整除
+            return new Double[]{avg.doubleValue()};
+        } else {
+            //未整除，计算最后剩余分值，subtract总分减去平均分和数量的积
+            // 平均分加上剩余得分得到最后一个分值
+            BigDecimal lastScore = avg.add(bScore.subtract(avgAllScore));
+            return new Double[]{avg.doubleValue(), lastScore.doubleValue()};
+        }
+    }
 }

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paper/PaperQsVo.java

@@ -0,0 +1,34 @@
+package com.xhkjedu.sstudy.vo.paper;
+
+import lombok.Data;
+
+/**
+ * @Description
+ * @Author WN
+ * Date 2022/10/17 16:58
+ **/
+@Data
+public class PaperQsVo {
+    private String qtname;//名称
+
+    private double score;//分值
+
+    private int num;//数量
+
+    private double srate;//分值占比
+
+    private double nrate;//数量占比
+
+    private String qns;//小题题号
+    public PaperQsVo(){
+
+    }
+
+    public PaperQsVo(String qtname, double score, int num, double srate, double nrate){
+        this.qtname = qtname;
+        this.score = score;
+        this.num = num;
+        this.srate = srate;
+        this.nrate = nrate;
+    }
+}

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paper/PaperQtypeQuesVo.java

@@ -0,0 +1,57 @@
+package com.xhkjedu.sstudy.vo.paper;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description
+ * @Author WN
+ * Date 2022/10/17 15:52
+ **/
+@Data
+public class PaperQtypeQuesVo {
+    private Integer ptqid;
+
+    private String questionid;
+
+    private String qtypeid;
+
+    private String qtypename;
+
+    private Integer ctype;
+
+    private Integer qlevel;
+
+    private Integer sorder;
+
+    private Integer snum;
+
+    private Integer complexity;
+
+    private Double ptqscore;
+
+    private Integer ptqorder;
+
+    private String qn;
+
+    private String questionpid;
+
+    private Double mscore;
+
+    private String mqtypeid;
+
+    private String mqtypename;
+
+    private Integer mctype;
+
+    private Integer mqlevel;
+
+    private Integer mcomplexity;
+
+    private List<Map> points = new ArrayList<>();//知识点
+
+    private List<PaperQtypeQuesVo> sonques = new ArrayList<>();
+}

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paper/PaperQtypeVo.java

@@ -3,10 +3,12 @@ package com.xhkjedu.sstudy.vo.paper;
 import com.xhkjedu.sstudy.vo.question.QuestionVo;
 import lombok.Data;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @Data
 public class PaperQtypeVo {
+    private Integer ptid;
     //题型id
     private String qtypeid;
 
@@ -27,4 +29,6 @@ public class PaperQtypeVo {
 
     //试题集合
     private List<QuestionVo> questions;
+
+    private List<PaperQtypeQuesVo> quelist = new ArrayList<>();
 }

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paper/QuestionOrderVo.java

@@ -0,0 +1,33 @@
+package com.xhkjedu.sstudy.vo.paper;
+
+import lombok.Data;
+
+/**
+ * @Description
+ * @Author WN
+ * Date 2022/10/17 16:43
+ **/
+@Data
+public class QuestionOrderVo {
+    private String id;
+
+    private String name;
+
+    private Integer complexity;
+
+    //试题类型1单题2母题
+    private Integer qlevel;
+
+    private Double score;//试题分值
+
+    //试题题号（单题、母题） （子题不占题号）
+    private Integer order;
+
+    private String questionid;//试题id（单题id,母题id）
+
+    //试题题号对应子题在试卷中id(单题时数组长度为1)
+    private Integer[] ptqids;
+
+    //试题题号对应子题在试卷中显示的题号(单题时数组长度为1)
+    private String[] qns;
+}

sstudy/src/main/java/com/xhkjedu/sstudy/vo/paper/QuestionPointVo.java

@@ -0,0 +1,22 @@
+package com.xhkjedu.sstudy.vo.paper;
+
+import lombok.Data;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description
+ * @Author WN
+ * Date 2022/10/17 16:45
+ **/
+@Data
+public class QuestionPointVo {
+    private Integer order;//试题排序
+    private Integer ptqid;//试卷中试题id单题，母子题的情况下为0
+    private String questionid;//试题id
+    private Double score;//单题、母题分值
+    private Integer qlevel;//试题级别1单题2母题
+    private List<Integer> ptqids;//试题子题集合
+    private List<Map> pointids;//知识点id和知识点分值
+}

sstudy/src/main/resources/mapper/paper/PaperQtypeMapper.xml

@@ -5,4 +5,57 @@
     <delete id="deleteByPaperid">
         DELETE FROM t_paper_qtype WHERE paperid=#{paperid}
     </delete>
+
+    <resultMap id="qtypesQuestions" type="com.xhkjedu.sstudy.vo.paper.PaperQtypeVo">
+        <result column="ptid" property="ptid"></result>
+        <result column="qtypeid" property="qtypeid"></result>
+        <result column="qtypename" property="qtypename"></result>
+        <result column="ptorder" property="ptorder"></result>
+        <result column="ptscore" property="ptscore"></result>
+        <result column="ptnum" property="ptnum"></result>
+        <collection property="quelist" ofType="com.xhkjedu.sstudy.vo.paper.PaperQtypeQuesVo" javaType="java.util.List">
+            <result column="ptqid" property="ptqid"></result>
+            <result column="questionid" property="questionid"></result>
+            <result column="qtypeid" property="qtypeid"></result>
+            <result column="qtypename" property="qtypename"></result>
+            <result column="ctype" property="ctype"></result>
+            <result column="qlevel" property="qlevel"></result>
+            <result column="sorder" property="sorder"></result>
+            <result column="snum" property="snum"></result>
+            <result column="complexity" property="complexity"></result>
+            <result column="ptqscore" property="ptqscore"></result>
+            <result column="ptqorder" property="ptqorder"></result>
+            <result column="qn" property="qn"></result>
+            <result column="questionpid" property="questionpid"></result>
+            <result column="mscore" property="mscore"></result>
+            <result column="mqtypeid" property="mqtypeid"></result>
+            <result column="mqtypename" property="mqtypename"></result>
+            <result column="mctype" property="mctype"></result>
+            <result column="mqlevel" property="mqlevel"></result>
+            <result column="mcomplexity" property="mcomplexity"></result>
+            <collection property="points" ofType="java.util.Map" javaType="java.util.List"
+                        column="{questionid=questionid,qlevel=qlevel,questionpid=questionpid" select="listQuestionPoints">
+                <result column="pointid" property="pointid"></result>
+                <result column="pointname" property="pointname"></result>
+            </collection>
+        </collection>
+    </resultMap>
+
+    <!--试题详情-->
+    <select id="listPaperQtypeQuestions" resultMap="qtypesQuestions">
+        select t.ptid,t.qtypeid,t.qtypename,t.ptorder,t.ptscore,t.ptnum,tq.ptqid,tq.questionid,q.qtypeid,q.qtypename,q.ctype,
+               q.qlevel,q.sorder,q.snum,q.complexity,tq.ptqscore,tq.ptqorder,tq.qn,tq.questionpid,tq.mscore,tq.mqtypeid,
+               tq.mqtypename,q1.ctype mctype,q1.qlevel mqlevel,q1.complexity mcomplexity
+                from t_paper_qtype_question tq left join t_paper_qtype t on t.ptid=tq.ptid
+                left join t_question q on tq.questionid=q.questionid
+                left JOIN t_question q1 on tq.questionpid=q1.questionid
+         where t.paperid=#{paperid} order by t.ptorder,tq.ptqorder,q.sorder
+    </select>
+    <!--试题关联知识点-->
+    <select id="listQuestionPoints" resultType="java.util.Map">
+        select qp.pointid,p.pointname from t_question_point qp
+        left join t_point p on qp.pointid=p.pointid
+        where qp.questionid=#{questionpid} group by qp.pointid order by p.pointorder
+    </select>
+
 </mapper>

sstudy/src/main/resources/mapper/paper/PaperScantronMapper.xml

@@ -9,7 +9,7 @@
         GROUP_CONCAT(ps.psorder) AS orders
         FROM t_paper_scantron_qtype psq LEFT JOIN t_paper_scantron ps ON psq.psqtypeid=ps.psqtypeid
         LEFT JOIN t_paper p ON  psq.paperid=p.paperid
-        WHERE p.papertype=2 AND psq.paperid=#{paperid} GROUP BY psq.qtypeid ORDER BY psq.pstorder
+        WHERE p.papertype=2 AND psq.paperid=#{paperid} GROUP BY psq.qtypename ORDER BY psq.pstorder
     </select>
     <!--获取答题卡详情-->
     <select id="findById" resultType="com.xhkjedu.sstudy.model.paper.TPaperScantron">