feat: 根据新KSD模型进行修改并测试

src/main/java/com/seecoder/dataanalysis/analysis/impl/EvalDataAnalysisServiceImpl.java

@@ -9,6 +9,7 @@ import com.seecoder.dataanalysis.data.entity.competency.*;
 import com.seecoder.dataanalysis.data.entity.eval.EvalExamInfo;
 import com.seecoder.dataanalysis.data.entity.eval.EvalExamRecord;
 import com.seecoder.dataanalysis.data.entity.eval.Question;
+import com.seecoder.dataanalysis.logic.question.QuestionService;
 import com.sun.xml.internal.bind.v2.TODO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -30,7 +31,7 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
     @Autowired
     private CompetencyTreeDao competencyTreeDao;
     @Autowired
-    private QuestionDao questionDao;
+    private QuestionService questionService;
 
     @Override
     public CompetencyTree getTreeById(int userId){
@@ -50,50 +51,50 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
         List<KSDScore> modelKSD = modelTree.getSubCompetencyTree();
         List<KSDScore> tarKSD = competencyTree.getSubCompetencyTree();
 
-        for(KSDScore ksdScore : tarKSD){
-            String tarCom = ksdScore.getCompetency();
-            List<KSScore> tarKS = ksdScore.getKSScore();
-            List<DScore> tarD = ksdScore.getDScore();
-
-            //找到对应的KSD树，开始进行KS和D的匹配
-            for(KSDScore KSDModel : modelKSD){
-                if(KSDModel.getCompetency().equals(tarCom)){
-                    KSDModel.setTotalScore(ksdScore.getTotalScore());
-                    //进行KS的匹配
-                    List<KSScore> modelKS = KSDModel.getKSScore();
-                    for(KSScore ksScore : tarKS){
-                        String tarSub = ksScore.getKnowledge();
-                        List<Double> tarSkillScore = ksScore.getSkillsAndScore();
-
-                        for(KSScore KSModel : modelKS){
-                            if(KSModel.getKnowledge().equals(tarSub)){
-                                List<Double> after = KSModel.getSkillsAndScore();
-                                for(int i=0;i<tarSkillScore.size();i++){
-                                    after.set(i,tarSkillScore.get(i));
-                                }
-                                KSModel.setSkillsAndScore(after);
-                                break;
-                            }
-                        }
-                    }
-                    KSDModel.setKSScore(modelKS);
-                    //进行D的匹配
-                    List<DScore> modelD = KSDModel.getDScore();
-                    for(DScore dScore : tarD){
-                        String tarName = dScore.getName();
-
-                        for(DScore DModel : modelD){
-                            if(DModel.getName().equals(tarName)){
-                                DModel.setScore(dScore.getScore());
-                                break;
-                            }
-                        }
-                    }
-                    KSDModel.setDScore(modelD);
-                    break;
-                }
-            }
-        }
+//        for(KSDScore ksdScore : tarKSD){
+//            String tarCom = ksdScore.getCompetency();
+//            List<KSScore> tarKS = ksdScore.getKSScore();
+//            List<DScore> tarD = ksdScore.getDScore();
+//
+//            //找到对应的KSD树，开始进行KS和D的匹配
+//            for(KSDScore KSDModel : modelKSD){
+//                if(KSDModel.getCompetency().equals(tarCom)){
+//                    KSDModel.setTotalScore(ksdScore.getTotalScore());
+//                    //进行KS的匹配
+//                    List<KSScore> modelKS = KSDModel.getKSScore();
+//                    for(KSScore ksScore : tarKS){
+//                        String tarSub = ksScore.getKnowledge();
+//                        List<Double> tarSkillScore = ksScore.getSkillsAndScore();
+//
+//                        for(KSScore KSModel : modelKS){
+//                            if(KSModel.getKnowledge().equals(tarSub)){
+//                                List<Double> after = KSModel.getSkillsAndScore();
+//                                for(int i=0;i<tarSkillScore.size();i++){
+//                                    after.set(i,tarSkillScore.get(i));
+//                                }
+//                                KSModel.setSkillsAndScore(after);
+//                                break;
+//                            }
+//                        }
+//                    }
+//                    KSDModel.setKSScore(modelKS);
+//                    //进行D的匹配
+//                    List<DScore> modelD = KSDModel.getDScore();
+//                    for(DScore dScore : tarD){
+//                        String tarName = dScore.getName();
+//
+//                        for(DScore DModel : modelD){
+//                            if(DModel.getName().equals(tarName)){
+//                                DModel.setScore(dScore.getScore());
+//                                break;
+//                            }
+//                        }
+//                    }
+//                    KSDModel.setDScore(modelD);
+//                    break;
+//                }
+//            }
+//        }
 
         modelTree.setSubCompetencyTree(modelKSD);
 
@@ -101,13 +102,12 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
     }
 
     @Override
-    public CompetencyTree getTreeAfterExam(int recordId){
-        //TODO 测试检查
+    public CompetencyTree getTreeAfterExam(int recordId) {
 
         EvalExamRecord evalExamRecord = evalExamRecordDao.findById(recordId).get();
 
         Optional<EvalExamInfo> result1 = evalExamInfoDao.findById(evalExamRecord.getExamId());
-        if(!result1.isPresent()){
+        if (!result1.isPresent()) {
             System.out.println("考试信息不存在");
             return null;
         }
@@ -116,10 +116,11 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
         CompetencyTree competencyTree;
 
         Optional<CompetencyTree> result2 = competencyTreeDao.findById(evalExamRecord.getUserId());
-        if(!result2.isPresent()){
+        if (!result2.isPresent()) {
+            //若查找不到能力树就新建一棵
             competencyTree = new CompetencyTree(evalExamRecord.getUserId());
-        }else {
-            competencyTree  = competencyTreeDao.findById(evalExamRecord.getUserId()).get();
+        } else {
+            competencyTree = competencyTreeDao.findById(evalExamRecord.getUserId()).get();
         }
 
         //数据取完，开始进行KSD分析和入库
@@ -129,109 +130,208 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
         String disposition = evalExamInfo.getDisposition();
 //        System.out.println(competencyTree);
         Double tree_Score = competencyTree.getTreeScore();
-        double[] difficulty_percent = new double[]{1.0,1.25,1.5,1.75,2.0};
+        double[] difficulty_percent = new double[]{1.0, 1.25, 1.5, 1.75, 2.0};
         //得到学生所有题目的得分
         Map<String, Double> studentScores = evalExamRecord.getErrorQuestions();
-//        Map<String,Double> questionAndScore = evalExamInfo.getQuestionAndScore();
-        //修改成不初始化，而是逐条添加的模式
-        for(Map.Entry<String,Double> entry : studentScores.entrySet()){
+        Map<String, Double> questionAndScore = evalExamInfo.getQuestionAndScore();
+        //修改成不初始化，而是逐条添加的模式，对每一题进行分析入库
+        for (Map.Entry<String, Double> entry : studentScores.entrySet()) {
             String questionId = entry.getKey();
-            Question question = questionDao.findById(questionId).get();
+            Question question = questionService.getQuestionById(questionId);
+            List<String> knowledgeList = question.getCompetencies();
+            Integer weight = question.getWeight();
 
             //能力树中的加分 = 学生得分 * 试卷难度
-            Double addScore = difficulty_percent[difficulty-1] * studentScores.get(questionId);
+            Double addScore = difficulty_percent[difficulty - 1] * studentScores.get(questionId);
             //增加能力树总分,注意，每个competency都会加分
-            tree_Score += (addScore*question.getCompetencies().size());
-
-            for(int i=0;i<question.getCompetencies().size();i++){
-                String competency = question.getCompetencies().get(i);
-                KSScore ksScoreMessage = question.getKsScores().get(i);
-
-                //判定当前的subTree中是否添加过该分支，若添加过则直接修改，否则要新建分支
-                boolean existCom = false;
-                KSDScore changeKSDScore = new KSDScore();
-                //根据competency找大分类
-                for(KSDScore ksdScore : subTree){
-                    //competency大分支存在
-                    if(ksdScore.getCompetency().equals(competency)){
-                        existCom = true;
-                        changeKSDScore = ksdScore;
+            tree_Score += (addScore * knowledgeList.size());
+
+            //处理每一个知识点分支
+            for (int i = 0; i < knowledgeList.size(); i++) {
+                //知识点的形式一般为SR.RA.RC这种，需要用.分割并处理
+                String[] competencies = knowledgeList.get(i).split("\\.");
+                String com1 = competencies[0];
+                boolean existCom1 = false;
+                KSDScore changeKSD1 = new KSDScore();
+                for (KSDScore ksdScore : subTree) {
+                    if (ksdScore.getCompetency().equals(com1)) {
+                        existCom1 = true;
+                        changeKSD1 = ksdScore;
                         break;
                     }
                 }
-                //competency大分支不存在，需要添加
-                if(existCom == false){
-                    changeKSDScore.setCompetency(competency);
-                    changeKSDScore.setTotalScore(0.0);
-                    List<KSScore> addKs = new ArrayList<>();
+                if (!existCom1) {
                     List<DScore> addD = new ArrayList<>();
-                    changeKSDScore.setKSScore(addKs);
-                    changeKSDScore.setDScore(addD);
+                    Double[] ds = new Double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+                    List<Double> addS = Arrays.asList(ds);
+                    List<KSDScore> addChild = new ArrayList<>();
+
+                    changeKSD1.setCompetency(com1);
+                    changeKSD1.setTotalScore(0.0);
+                    changeKSD1.setSkillsAndScores(addS);
+                    changeKSD1.setDScore(addD);
+                    changeKSD1.setChildren(addChild);
                 }
 
-
-                //增加该KSD子树的分数
-                Double total_score = changeKSDScore.getTotalScore();
-                total_score += addScore;
-                changeKSDScore.setTotalScore(total_score);
-
-                //开始处理KSScore，记录子分支是否存在
-                boolean existSubCom = false;
-                //在对应的competency下进行下一步小分类
-                List<KSScore> subKS = changeKSDScore.getKSScore();
-                KSScore changeKSScore = new KSScore();
-                for(KSScore ksScore : subKS){
-                    if(ksScore.getKnowledge().equals(ksScoreMessage.getKnowledge())){
-                        existSubCom = true;
-                        changeKSScore = ksScore;
-                        break;
+                //处理该层的KSD结果，增加总分
+                Double totalScore1 = changeKSD1.getTotalScore();
+                totalScore1 += addScore;
+                changeKSD1.setTotalScore(totalScore1);
+                //增加skills分数
+                List<Double> skillsAndScores1 = changeKSD1.getSkillsAndScores();
+                Double skillScore1 = skillsAndScores1.get(weight - 1);
+                skillScore1 += addScore;
+                skillsAndScores1.set(weight - 1, skillScore1);
+                changeKSD1.setSkillsAndScores(skillsAndScores1);
+                if(disposition!=null){
+                    //增加disposition分数
+                    boolean existD1 = false;
+                    List<DScore> subD1 = changeKSD1.getDScore();
+                    DScore changeD1 = new DScore();
+                    for (DScore dScore : subD1) {
+                        if (dScore.getName().equals(disposition)) {
+                            existD1 = true;
+                            changeD1 = dScore;
+                            break;
+                        }
                     }
-                }
-                //sub小分支不存在，需要添加并对分支名称和分数进行初始化
-                if(existSubCom == false){
-                    changeKSScore.setKnowledge(ksScoreMessage.getKnowledge());
-                    changeKSScore.setSkillsAndScore(Arrays.asList(new Double[]{0.0,0.0,0.0,0.0,0.0,0.0}));
-                }
-                List<Double> skills = changeKSScore.getSkillsAndScore();
-                for(int j=0;j<skills.size();j++){
-                    Double score = ksScoreMessage.getSkillsAndScore().get(j) * addScore + skills.get(j);
-                    skills.set(j,score);
-                }
-                changeKSScore.setSkillsAndScore(skills);
-                //需要增加新建的KS子分支
-                if(existSubCom == false){
-                    subKS.add(changeKSScore);
-                }
-
-
-                //开始处理DScore，记录该品质是否存在
-                boolean existD = false;
-                List<DScore> subD = changeKSDScore.getDScore();
-                DScore changeDScore = new DScore();
-                for(DScore dScore : subD){
-                    if(dScore.getName().equals(disposition)){
-                        existD = true;
-                        changeDScore = dScore;
-                        break;
+                    if (!existD1) {
+                        changeD1.setName(disposition);
+                        changeD1.setScore(0.0);
                     }
+                    Double addDScore1 = addScore + changeD1.getScore();
+                    changeD1.setScore(addDScore1);
+                    //需要增加新建的D子分支
+                    if (!existD1) {
+                        subD1.add(changeD1);
+                    }
+                    changeKSD1.setDScore(subD1);
+                }else {
+                    System.out.println("disposition信息不存在");
                 }
-                if(existD == false){
-                    changeDScore.setName(disposition);
-                    changeDScore.setScore(0.0);
-                }
-                Double addDScore = addScore + changeDScore.getScore();
-                changeDScore.setScore(addDScore);
-                //需要增加新建的D子分支
-                if(existD == false){
-                    subD.add(changeDScore);
+
+                if (!existCom1) {
+                    subTree.add(changeKSD1);
                 }
 
-                //处理完KS分支和D分支
-                changeKSDScore.setKSScore(subKS);
-                changeKSDScore.setDScore(subD);
+                //如果有子层需要处理
+                List<KSDScore> subTree1 = changeKSD1.getChildren();
+                if (competencies.length > 1) {
+                    String com2 = competencies[1];
+                    boolean existCom2 = false;
+                    KSDScore changeKSD2 = new KSDScore();
+                    for (KSDScore ksdScore : subTree1) {
+                        if (ksdScore.getCompetency().equals(com2)) {
+                            existCom2 = true;
+                            changeKSD2 = ksdScore;
+                            break;
+                        }
+                    }
+                    if (!existCom2) {
+                        List<DScore> addD = new ArrayList<>();
+                        Double[] ds = new Double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+                        List<Double> addS = Arrays.asList(ds);
+                        List<KSDScore> addChild = new ArrayList<>();
+
+                        changeKSD2.setCompetency(com2);
+                        changeKSD2.setTotalScore(0.0);
+                        changeKSD2.setSkillsAndScores(addS);
+                        changeKSD2.setDScore(addD);
+                        changeKSD2.setChildren(addChild);
+                    }
+                    Double totalScore2 = changeKSD2.getTotalScore();
+                    totalScore2 += addScore;
+                    changeKSD2.setTotalScore(totalScore2);
+                    List<Double> skillsAndScores2 = changeKSD2.getSkillsAndScores();
+                    Double skillScore2 = skillsAndScores2.get(weight - 1);
+                    skillScore2 += addScore;
+                    skillsAndScores2.set(weight - 1, skillScore2);
+                    changeKSD2.setSkillsAndScores(skillsAndScores2);
+                    if(disposition!=null){
+                        boolean existD2 = false;
+                        List<DScore> subD2 = changeKSD2.getDScore();
+                        DScore changeD2 = new DScore();
+                        for (DScore dScore : subD2) {
+                            if (dScore.getName().equals(disposition)) {
+                                existD2 = true;
+                                changeD2 = dScore;
+                                break;
+                            }
+                        }
+                        if (!existD2) {
+                            changeD2.setName(disposition);
+                            changeD2.setScore(0.0);
+                        }
+                        Double addDScore2 = addScore + changeD2.getScore();
+                        changeD2.setScore(addDScore2);
+                        if (!existD2) {
+                            subD2.add(changeD2);
+                        }
+                        changeKSD2.setDScore(subD2);
+                    }
+                    if (!existCom2) {
+                        subTree1.add(changeKSD2);
+                    }
 
-                if(existCom == false){
-                    subTree.add(changeKSDScore);
+                    //如果有子层需要处理
+                    List<KSDScore> subTree2 = changeKSD2.getChildren();
+                    if (competencies.length > 2) {
+                        String com3 = competencies[2];
+                        boolean existCom3 = false;
+                        KSDScore changeKSD3 = new KSDScore();
+                        for (KSDScore ksdScore : subTree2) {
+                            if (ksdScore.getCompetency().equals(com3)) {
+                                existCom3 = true;
+                                changeKSD3 = ksdScore;
+                                break;
+                            }
+                        }
+                        if (!existCom3) {
+                            List<DScore> addD = new ArrayList<>();
+                            Double[] ds = new Double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+                            List<Double> addS = Arrays.asList(ds);
+                            List<KSDScore> addChild = new ArrayList<>();
+
+                            changeKSD3.setCompetency(com3);
+                            changeKSD3.setTotalScore(0.0);
+                            changeKSD3.setSkillsAndScores(addS);
+                            changeKSD3.setDScore(addD);
+                            changeKSD3.setChildren(addChild);
+                        }
+                        Double totalScore3 = changeKSD3.getTotalScore();
+                        totalScore3 += addScore;
+                        changeKSD3.setTotalScore(totalScore3);
+                        List<Double> skillsAndScores3 = changeKSD3.getSkillsAndScores();
+                        Double skillScore3 = skillsAndScores3.get(weight - 1);
+                        skillScore3 += addScore;
+                        skillsAndScores3.set(weight - 1, skillScore3);
+                        changeKSD3.setSkillsAndScores(skillsAndScores3);
+                        if(disposition!=null){
+                            boolean existD3 = false;
+                            List<DScore> subD3 = changeKSD3.getDScore();
+                            DScore changeD3 = new DScore();
+                            for (DScore dScore : subD3) {
+                                if (dScore.getName().equals(disposition)) {
+                                    existD3 = true;
+                                    changeD3 = dScore;
+                                    break;
+                                }
+                            }
+                            if (!existD3) {
+                                changeD3.setName(disposition);
+                                changeD3.setScore(0.0);
+                            }
+                            Double addDScore3 = addScore + changeD3.getScore();
+                            changeD3.setScore(addDScore3);
+                            if (!existD3) {
+                                subD3.add(changeD3);
+                            }
+                            changeKSD3.setDScore(subD3);
+                        }
+                        if (!existCom3) {
+                            subTree2.add(changeKSD3);
+                        }
+                    }
                 }
             }
         }
@@ -249,24 +349,31 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
         List<EvalExamRecord> evalExamRecordList = evalExamRecordDao.findByUserId(userId);
         Map<String,Double> res = new HashMap<>();
         for(EvalExamRecord evalExamRecord : evalExamRecordList){
-//            System.out.println(evalExamRecord);
+            Optional<EvalExamInfo> result = evalExamInfoDao.findById(evalExamRecord.getExamId());
+            if(!result.isPresent()){
+                System.out.println("找不到对应考试信息");
+                continue;
+            }
+            EvalExamInfo evalExamInfo = evalExamInfoDao.findById(evalExamRecord.getExamId()).get();
+            //获得题目ID和题目分数的对应关系
+            Map<String,Double> questionAndScore = evalExamInfo.getQuestionAndScore();
             Map<String,Double> errorQuestions = evalExamRecord.getErrorQuestions();
             for(String questionId : errorQuestions.keySet()){
-                Optional<Question> result = questionDao.findById(questionId);
-                if(!result.isPresent()){
-                    System.out.println("题号不存在");
-                    continue;
-                }
-                Question question = questionDao.findById(questionId).get();
+//                Optional<Question> result = questionDao.findById(questionId);
+//                if(!result.isPresent()){
+//                    System.out.println("题号不存在");
+//                    continue;
+//                }
+                Question question = questionService.getQuestionById(questionId);
                 //如果题目分数为0，则跳过该题不做分析
-                if(question.getQuestionScore() == 0){
+                if(questionAndScore.get(questionId) == 0){
                     continue;
                 }
 //                System.out.println(errorQuestions.get(questionId));
 //                System.out.println(question.getQuestionScore());
                 //如果做过相同的题目，则取最高分
                 DecimalFormat df = new DecimalFormat("#.00");
-                Double scorePercent = errorQuestions.get(questionId)/question.getQuestionScore();
+                Double scorePercent = errorQuestions.get(questionId)/questionAndScore.get(questionId);
                 if(res.containsKey(questionId)){
                     scorePercent = Math.max(scorePercent,res.get(questionId));
                 }

src/main/java/com/seecoder/dataanalysis/data/entity/competency/CompetencyTree.java

@@ -95,7 +95,7 @@ public class CompetencyTree {
                 dScoreList.add(dScore);
             }
 
-            ksdScore.setKSScore(ksScoreList);
+//            ksdScore.setKSScore(ksScoreList);
             ksdScore.setDScore(dScoreList);
 
             ksdScoreList.add(ksdScore);
@@ -112,9 +112,9 @@ public class CompetencyTree {
         for(KSDScore ksdScore : this.subCompetencyTree){
             System.out.println(ksdScore.getCompetency());
             System.out.println(ksdScore.getTotalScore());
-            for(KSScore ksScore : ksdScore.getKSScore()){
-                System.out.print(ksScore.getKnowledge()+" "+ksScore.getSkillsAndScore()+" ");
-            }
+//            for(KSScore ksScore : ksdScore.getKSScore()){
+//                System.out.print(ksScore.getKnowledge()+" "+ksScore.getSkillsAndScore()+" ");
+//            }
             System.out.println();
             for(DScore dScore : ksdScore.getDScore()){
                 System.out.print(dScore.getName()+" ");

src/main/java/com/seecoder/dataanalysis/data/entity/competency/KSDScore.java

@@ -16,7 +16,7 @@ import java.util.List;
 public class KSDScore {
 
     /**
-     * 能力名称
+     * 能力名称-knowledge
      **/
     @Field("competency")
     private String competency;
@@ -25,15 +25,28 @@ public class KSDScore {
      **/
     @Field("total_score")
     private Double totalScore;
-    /**
-     * 知识-knowledge
-     **/
-    @Field("ks_score")
-    private List<KSScore> KSScore;
+
+//    /**
+//     * 知识-knowledge
+//     **/
+//    @Field("ks_score")
+//    private List<KSScore> KSScore;
 
     /**
      * 性情-deposition
      **/
     @Field("d_score")
     private List<DScore> DScore;
+
+    /**
+     * 技能(掌握程度)-skills
+     */
+    @Field("s_score")
+    private List<Double> SkillsAndScores;
+
+    /**
+     * 能力子分支
+     */
+    @Field("sub_com")
+    private List<KSDScore> children;
 }

src/main/java/com/seecoder/dataanalysis/data/entity/eval/Question.java

@@ -1,20 +1,24 @@
 package com.seecoder.dataanalysis.data.entity.eval;
 
 import com.seecoder.dataanalysis.data.entity.competency.KSScore;
+import com.seecoder.dataanalysis.vo.question.CompleteQuestionVO;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
+import org.jetbrains.annotations.NotNull;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.Field;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 /**
  * @author Peng Yiyan
  */
-@Document(collection = "question")
 @NoArgsConstructor
 @AllArgsConstructor
 @Accessors(chain = true)
@@ -24,26 +28,83 @@ public class Question {
     /**
      * 题目id
      */
-    @Id
-    @Field("question_id")
     private String questionId;
 
+//    /**
+//     * 题目总分值
+//     */
+//    private Double questionScore;
+
     /**
-     * 题目总分值
+     * 题目难度，用于Skills
      */
-    @Field("question_score")
-    private Double questionScore;
+    private Integer weight;
 
     /**
      * 题目考察的能力，可能考察多种不同能力，所以用list存储
      */
-    @Field("competencies")
     private List<String> competencies;
 
+//    /**
+//     * 题目考察的K-S对，和competencies中的下标一一对应
+//     */
+//    private List<KSScore> ksScores;
+
     /**
-     * 题目考察的K-S对，和competencies中的下标一一对应
+     * 解析CompleteQuestionVO的内容，并放入Question中
+     * @param completeQuestionVO
      */
-    @Field("ks_Scores")
-    private List<KSScore> ksScores;
+    public Question(CompleteQuestionVO completeQuestionVO){
+        this.setQuestionId(completeQuestionVO.getId());
+        this.setWeight(completeQuestionVO.getWeight());
+        List<String> knowledgeList = completeQuestionVO.getKnowledgeId();
+//        String[] testArray = new String[]{"SR.RV.RT","SR.RV","SR.RC.INRP","SC","SC.RT","SR","SSR"};
+//        List<String> knowledgeList = Arrays.asList(testArray);
+//        Collections.sort(knowledgeList,(a,b) -> b.split(".").length - a.split(".").length);
+
+        Collections.sort(knowledgeList,(a,b) -> countPoint(b) - countPoint(a));
+//        for(String str : knowledgeList)
+//            System.out.println(str);
+        //处理重复知识点后的结果数组
+        List<String> after = new ArrayList<>();
+
+        after.add(knowledgeList.get(0));
+        int index = 1;
+        for(;index<knowledgeList.size();index++){
+            if(countPoint(knowledgeList.get(index)) == countPoint(knowledgeList.get(index-1))){
+                after.add(knowledgeList.get(index));
+            }else {
+                break;
+            }
+        }
+
+        for(;index<knowledgeList.size();index++){
+            boolean overlap = false;
+            for(String have : after){
+                if(have.contains(knowledgeList.get(index))){
+                    overlap = true;
+                    break;
+                }
+            }
+            if(!overlap){
+                after.add(knowledgeList.get(index));
+            }
+        }
+
+        this.setCompetencies(after);
+
+    }
+
+    //计算字符串中.(分隔符)的数目
+    int countPoint(String s){
+        int count = 0;
+        for(int i=0;i<s.length();i++){
+            if(s.charAt(i) == '.'){
+                count++;
+            }
+        }
+        return count;
+    }
+
 
 }

src/test/java/com/seecoder/dataanalysis/DataAnalysisApplicationTests.java

@@ -38,34 +38,34 @@ class DataAnalysisApplicationTests {
     private DevcloudInfoDao devcloudInfoDao;
 
 
-    @Test
-    void saveTree(){
-        List<KSScore> L1 = new ArrayList<>();
-        List<DScore> L2 = new ArrayList<>();
-        List<Double> L4 = new ArrayList<>();
-        L4.add(1.0);
-        KSScore ksScore = new KSScore()
-                .setKnowledge("test1")
-                .setSkillsAndScore(L4);
-        DScore dScore = new DScore()
-                .setName("active")
-                .setScore(10.0);
-        L1.add(ksScore);
-        L2.add(dScore);
-        KSDScore ksdScore = new KSDScore()
-                .setCompetency("test")
-                .setTotalScore(1000.0)
-                .setDScore(L2)
-                .setKSScore(L1);
-        List<KSDScore> L3 = new ArrayList<>();
-        L3.add(ksdScore);
-        CompetencyTree competencyTree = new CompetencyTree()
-                .setUserId(2)
-                .setSubCompetencyTree(L3);
-
-        competencyTreeDao.save(competencyTree);
-
-    }
+//    @Test
+//    void saveTree(){
+//        List<KSScore> L1 = new ArrayList<>();
+//        List<DScore> L2 = new ArrayList<>();
+//        List<Double> L4 = new ArrayList<>();
+//        L4.add(1.0);
+//        KSScore ksScore = new KSScore()
+//                .setKnowledge("test1")
+//                .setSkillsAndScore(L4);
+//        DScore dScore = new DScore()
+//                .setName("active")
+//                .setScore(10.0);
+//        L1.add(ksScore);
+//        L2.add(dScore);
+//        KSDScore ksdScore = new KSDScore()
+//                .setCompetency("test")
+//                .setTotalScore(1000.0)
+//                .setDScore(L2)
+//                .setKSScore(L1);
+//        List<KSDScore> L3 = new ArrayList<>();
+//        L3.add(ksdScore);
+//        CompetencyTree competencyTree = new CompetencyTree()
+//                .setUserId(2)
+//                .setSubCompetencyTree(L3);
+//
+//        competencyTreeDao.save(competencyTree);
+//
+//    }
 
     @Test
     void saveExam(){

src/test/java/com/seecoder/dataanalysis/eval/impl/EvalDataAnalysisServiceImplTest.java

@@ -10,9 +10,11 @@ import com.seecoder.dataanalysis.data.entity.competency.*;
 import com.seecoder.dataanalysis.data.entity.eval.EvalExamInfo;
 import com.seecoder.dataanalysis.data.entity.eval.EvalExamRecord;
 import com.seecoder.dataanalysis.data.entity.eval.Question;
+import com.seecoder.dataanalysis.logic.question.QuestionService;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.TestComponent;
 
 import java.util.*;
 
@@ -25,100 +27,126 @@ public class EvalDataAnalysisServiceImplTest {
     EvalExamRecordDao evalExamRecordDao;
     @Autowired
     EvalExamInfoDao evalExamInfoDao;
-    @Autowired
-    QuestionDao questionDao;
 
     @Autowired
     EvalDataAnalysisService evalDataAnalysisService;
     @Autowired
+    QuestionService questionService;
+    @Autowired
     EvalController evalController;
 
-    @Test
-    void addQuestion(){
-        Question question1 = new Question().setQuestionId("abc123").setQuestionScore(50.0);
-        List<String> com1 = new ArrayList<>();
-        List<KSScore> ksScoreList1 = new ArrayList<>();
-        Double[] skills1 = new Double[]{0.0,1.0,0.0,1.0,0.0,1.0};
-        Double[] skills2 = new Double[]{1.0, 0.0, 0.0, 0.0, 0.0, 0.0};
-        com1.add("软件设计");
-        com1.add("软件构造");
-        com1.add("软件设计");
-        KSScore ksScore1 = new KSScore().setKnowledge("软件体系结构").setSkillsAndScore(Arrays.asList(skills1));
-        KSScore ksScore2 = new KSScore().setKnowledge("管理软件构造").setSkillsAndScore(Arrays.asList(skills1));
-        KSScore ksScore4 = new KSScore().setKnowledge("软件设计基础").setSkillsAndScore(Arrays.asList(skills2));
-        ksScoreList1.add(ksScore1);
-        ksScoreList1.add(ksScore2);
-        ksScoreList1.add(ksScore4);
-        question1.setCompetencies(com1).setKsScores(ksScoreList1);
-
-        Question question2 = new Question().setQuestionId("zxc111").setQuestionScore(30.0);
-        List<String> com2 = new ArrayList<>();
-        List<KSScore> ksScoreList2 = new ArrayList<>();
-        com2.add("软件维护");
-        KSScore ksScore3 = new KSScore().setKnowledge("软件维护基础").setSkillsAndScore(Arrays.asList(skills2));
-        ksScoreList2.add(ksScore3);
-        question2.setCompetencies(com2).setKsScores(ksScoreList2);
-
-        questionDao.save(question1);
-        questionDao.save(question2);
-
-        Question question3 = new Question().setQuestionId("abny").setQuestionScore(50.0);
-        List<String> com3 = new ArrayList<>();
-        List<KSScore> ksScoreList3 = new ArrayList<>();
-        com3.add("软件工程过程");
-        KSScore ksScore5 = new KSScore().setKnowledge("软件过程定义").setSkillsAndScore(Arrays.asList(skills2));
-        ksScoreList3.add(ksScore5);
-        question3.setCompetencies(com3).setKsScores(ksScoreList3);
-
-        questionDao.save(question3);
-    }
+//    @Test
+//    void addQuestion(){
+//        Question question1 = new Question().setQuestionId("abc123").setQuestionScore(50.0);
+//        List<String> com1 = new ArrayList<>();
+//        List<KSScore> ksScoreList1 = new ArrayList<>();
+//        Double[] skills1 = new Double[]{0.0,1.0,0.0,1.0,0.0,1.0};
+//        Double[] skills2 = new Double[]{1.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+//        com1.add("软件设计");
+//        com1.add("软件构造");
+//        com1.add("软件设计");
+//        KSScore ksScore1 = new KSScore().setKnowledge("软件体系结构").setSkillsAndScore(Arrays.asList(skills1));
+//        KSScore ksScore2 = new KSScore().setKnowledge("管理软件构造").setSkillsAndScore(Arrays.asList(skills1));
+//        KSScore ksScore4 = new KSScore().setKnowledge("软件设计基础").setSkillsAndScore(Arrays.asList(skills2));
+//        ksScoreList1.add(ksScore1);
+//        ksScoreList1.add(ksScore2);
+//        ksScoreList1.add(ksScore4);
+//        question1.setCompetencies(com1).setKsScores(ksScoreList1);
+//
+//        Question question2 = new Question().setQuestionId("zxc111").setQuestionScore(30.0);
+//        List<String> com2 = new ArrayList<>();
+//        List<KSScore> ksScoreList2 = new ArrayList<>();
+//        com2.add("软件维护");
+//        KSScore ksScore3 = new KSScore().setKnowledge("软件维护基础").setSkillsAndScore(Arrays.asList(skills2));
+//        ksScoreList2.add(ksScore3);
+//        question2.setCompetencies(com2).setKsScores(ksScoreList2);
+//
+//        questionDao.save(question1);
+//        questionDao.save(question2);
+//
+//        Question question3 = new Question().setQuestionId("abny").setQuestionScore(50.0);
+//        List<String> com3 = new ArrayList<>();
+//        List<KSScore> ksScoreList3 = new ArrayList<>();
+//        com3.add("软件工程过程");
+//        KSScore ksScore5 = new KSScore().setKnowledge("软件过程定义").setSkillsAndScore(Arrays.asList(skills2));
+//        ksScoreList3.add(ksScore5);
+//        question3.setCompetencies(com3).setKsScores(ksScoreList3);
+//
+//        questionDao.save(question3);
+//    }
 
     @Test
     void addExamInfo(){
-        Question question1 = questionDao.findById("abc123").get();
-        Question question2 = questionDao.findById("zxc111").get();
+        Question question1 = questionService.getQuestionById("43604f6f-f829-4aaf-ab97-47b99c20ede0");
+        Question question2 = questionService.getQuestionById("b39005ff-23c0-43a2-8174-f370f774eea8");
         Map<String,Double> questionAndScore1 = new HashMap<>();
-        questionAndScore1.put(question1.getQuestionId(),question1.getQuestionScore());
-        questionAndScore1.put(question2.getQuestionId(),question2.getQuestionScore());
+        questionAndScore1.put(question1.getQuestionId(),100.0);
+        questionAndScore1.put(question2.getQuestionId(),50.0);
 
         EvalExamInfo evalExamInfo1 = new EvalExamInfo()
                 .setExamId(1)
-                .setExamScore(question1.getQuestionScore()+question2.getQuestionScore())
+                .setExamScore(100.0)
                 .setUpdateTime(new Date())
                 .setStartTime(new Date())
                 .setEndTime(new Date())
                 .setDifficulty(1)
-                .setDisposition("热情")
                 .setQuestionAndScore(questionAndScore1);
 
         evalExamInfoDao.save(evalExamInfo1);
 
-        Question question3 = questionDao.findById("abny").get();
-        Map<String,Double> questionAndScore2 = new HashMap<>();
-        questionAndScore2.put(question1.getQuestionId(),question1.getQuestionScore());
-        questionAndScore2.put(question3.getQuestionId(),question3.getQuestionScore());
-
-        EvalExamInfo evalExamInfo2 = new EvalExamInfo()
-                .setExamId(2)
-                .setExamScore(question1.getQuestionScore()+question3.getQuestionScore())
-                .setUpdateTime(new Date())
-                .setStartTime(new Date())
-                .setEndTime(new Date())
-                .setDifficulty(1)
-                .setDisposition("责任心")
-                .setQuestionAndScore(questionAndScore2);
-
-        evalExamInfoDao.save(evalExamInfo2);
-
+        if(evalExamInfo1.getDisposition()==null){
+            System.out.println("null");
+        }else {
+            System.out.println(evalExamInfo1.getDisposition());
+        }
     }
 
+//    @Test
+//    void addExamInfo(){
+//        Question question1 = questionDao.findById("abc123").get();
+//        Question question2 = questionDao.findById("zxc111").get();
+//        Map<String,Double> questionAndScore1 = new HashMap<>();
+//        questionAndScore1.put(question1.getQuestionId(),question1.getQuestionScore());
+//        questionAndScore1.put(question2.getQuestionId(),question2.getQuestionScore());
+//
+//        EvalExamInfo evalExamInfo1 = new EvalExamInfo()
+//                .setExamId(1)
+//                .setExamScore(question1.getQuestionScore()+question2.getQuestionScore())
+//                .setUpdateTime(new Date())
+//                .setStartTime(new Date())
+//                .setEndTime(new Date())
+//                .setDifficulty(1)
+//                .setDisposition("热情")
+//                .setQuestionAndScore(questionAndScore1);
+//
+//        evalExamInfoDao.save(evalExamInfo1);
+//
+//        Question question3 = questionDao.findById("abny").get();
+//        Map<String,Double> questionAndScore2 = new HashMap<>();
+//        questionAndScore2.put(question1.getQuestionId(),question1.getQuestionScore());
+//        questionAndScore2.put(question3.getQuestionId(),question3.getQuestionScore());
+//
+//        EvalExamInfo evalExamInfo2 = new EvalExamInfo()
+//                .setExamId(2)
+//                .setExamScore(question1.getQuestionScore()+question3.getQuestionScore())
+//                .setUpdateTime(new Date())
+//                .setStartTime(new Date())
+//                .setEndTime(new Date())
+//                .setDifficulty(1)
+//                .setDisposition("责任心")
+//                .setQuestionAndScore(questionAndScore2);
+//
+//        evalExamInfoDao.save(evalExamInfo2);
+//
+//    }
+
     @Test
     void addExamRecord(){
-        Question question1 = questionDao.findById("abc123").get();
-        Question question2 = questionDao.findById("zxc111").get();
+        Question question1 = questionService.getQuestionById("43604f6f-f829-4aaf-ab97-47b99c20ede0");
+        Question question2 = questionService.getQuestionById("b39005ff-23c0-43a2-8174-f370f774eea8");
         Map<String, Double> quesScore1 = new HashMap<>();
-        quesScore1.put(question1.getQuestionId(),question1.getQuestionScore()-10.0);
-        quesScore1.put(question2.getQuestionId(),question2.getQuestionScore()-10.0);
+        quesScore1.put(question1.getQuestionId(),80.0);
+        quesScore1.put(question2.getQuestionId(),30.0);
 
         EvalExamRecord evalExamRecord1 = new EvalExamRecord()
                 .setRecordId(1)
@@ -129,59 +157,79 @@ public class EvalDataAnalysisServiceImplTest {
                 .setUserId(2);
 
         evalExamRecordDao.save(evalExamRecord1);
-
-        Question question3 = questionDao.findById("abny").get();
-        Map<String,Double> quesScore2 = new HashMap<>();
-        quesScore2.put(question1.getQuestionId(),question1.getQuestionScore());
-        quesScore2.put(question3.getQuestionId(),0.0);
-
-        EvalExamRecord evalExamRecord2 = new EvalExamRecord()
-                .setRecordId(2)
-                .setExamId(2)
-                .setScore(quesScore2.get(question1.getQuestionId())+quesScore2.get(question3.getQuestionId()))
-                .setErrorQuestions(quesScore2)
-                .setSubmitTime(new Date())
-                .setUserId(2);
-
-        evalExamRecordDao.save(evalExamRecord2);
     }
 
+//    @Test
+//    void addExamRecord(){
+//        Question question1 = questionDao.findById("abc123").get();
+//        Question question2 = questionDao.findById("zxc111").get();
+//        Map<String, Double> quesScore1 = new HashMap<>();
+//        quesScore1.put(question1.getQuestionId(),question1.getQuestionScore()-10.0);
+//        quesScore1.put(question2.getQuestionId(),question2.getQuestionScore()-10.0);
+//
+//        EvalExamRecord evalExamRecord1 = new EvalExamRecord()
+//                .setRecordId(1)
+//                .setExamId(1)
+//                .setScore(quesScore1.get(question1.getQuestionId())+quesScore1.get(question2.getQuestionId()))
+//                .setErrorQuestions(quesScore1)
+//                .setSubmitTime(new Date())
+//                .setUserId(2);
+//
+//        evalExamRecordDao.save(evalExamRecord1);
+//
+//        Question question3 = questionDao.findById("abny").get();
+//        Map<String,Double> quesScore2 = new HashMap<>();
+//        quesScore2.put(question1.getQuestionId(),question1.getQuestionScore());
+//        quesScore2.put(question3.getQuestionId(),0.0);
+//
+//        EvalExamRecord evalExamRecord2 = new EvalExamRecord()
+//                .setRecordId(2)
+//                .setExamId(2)
+//                .setScore(quesScore2.get(question1.getQuestionId())+quesScore2.get(question3.getQuestionId()))
+//                .setErrorQuestions(quesScore2)
+//                .setSubmitTime(new Date())
+//                .setUserId(2);
+//
+//        evalExamRecordDao.save(evalExamRecord2);
+//    }
+
+
+//    @Test
+//    void addTree(){
+//        List<KSScore> L1 = new ArrayList<>();
+//        List<DScore> L2 = new ArrayList<>();
+//        List<Double> L4 = new ArrayList<>();
+//        for(int i=0;i<6;i++){
+//            if(i%2==0){
+//                L4.add(0.0);
+//            }else {
+//                L4.add(10.0);
+//            }
+//        }
+//        KSScore ksScore = new KSScore()
+//                .setKnowledge("软件体系结构")
+//                .setSkillsAndScore(L4);
+//        DScore dScore = new DScore()
+//                .setName("细心")
+//                .setScore(10.0);
+//        L1.add(ksScore);
+//        L2.add(dScore);
+//        KSDScore ksdScore = new KSDScore()
+//                .setCompetency("软件设计")
+//                .setTotalScore(10.0)
+//                .setDScore(L2)
+//                .setKSScore(L1);
+//        List<KSDScore> L3 = new ArrayList<>();
+//        L3.add(ksdScore);
+//
+//        CompetencyTree competencyTree = new CompetencyTree()
+//                .setUserId(2)
+//                .setTreeScore(10.0)
+//                .setSubCompetencyTree(L3);
+//
+//        competencyTreeDao.save(competencyTree);
+//    }
 
-    @Test
-    void addTree(){
-        List<KSScore> L1 = new ArrayList<>();
-        List<DScore> L2 = new ArrayList<>();
-        List<Double> L4 = new ArrayList<>();
-        for(int i=0;i<6;i++){
-            if(i%2==0){
-                L4.add(0.0);
-            }else {
-                L4.add(10.0);
-            }
-        }
-        KSScore ksScore = new KSScore()
-                .setKnowledge("软件体系结构")
-                .setSkillsAndScore(L4);
-        DScore dScore = new DScore()
-                .setName("细心")
-                .setScore(10.0);
-        L1.add(ksScore);
-        L2.add(dScore);
-        KSDScore ksdScore = new KSDScore()
-                .setCompetency("软件设计")
-                .setTotalScore(10.0)
-                .setDScore(L2)
-                .setKSScore(L1);
-        List<KSDScore> L3 = new ArrayList<>();
-        L3.add(ksdScore);
-
-        CompetencyTree competencyTree = new CompetencyTree()
-                .setUserId(2)
-                .setTreeScore(10.0)
-                .setSubCompetencyTree(L3);
-
-        competencyTreeDao.save(competencyTree);
-    }
 
     @Test
     void testFindByUserId(){
@@ -212,7 +260,7 @@ public class EvalDataAnalysisServiceImplTest {
     @Test
     void testGetTreeAfterExam(){
 //        evalDataAnalysisService.getTreeAfterExam(2);
-        evalController.getTreeAfterExam(2);
+        evalController.getTreeAfterExam(1);
     }
 
     @Test

src/test/java/com/seecoder/dataanalysis/question/impl/QuestionServiceImplTest.java

@@ -17,7 +17,12 @@ public class QuestionServiceImplTest {
     private QuestionService questionService;
 
     @Test
-    void testGetQuestionId(){
+    void testGetQuestionId1(){
         questionService.getQuestionById("43604f6f-f829-4aaf-ab97-47b99c20ede0");
     }
+
+    @Test
+    void testGetQuestionId2(){
+        questionService.getQuestionById("b39005ff-23c0-43a2-8174-f370f774eea8");
+    }
 }