feat: 完成并测试读入json进行能力树初始化的功能，并对分析入库方式进行修改

pom.xml

@@ -59,6 +59,13 @@
             <version>0.9.1</version>
         </dependency>
 
+        <!--json字符串处理-->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.2.47</version>
+        </dependency>
+
         <!--日志服务-->
         <dependency>
             <groupId>com.nju.edu</groupId>
@@ -72,6 +79,20 @@
             </exclusions>
         </dependency>
 
+        <!--题库服务-->
+        <dependency>
+            <groupId>cn.seecoder</groupId>
+            <artifactId>seecoder-bok-client</artifactId>
+            <version>0.2.3</version>
+            <exclusions>
+                <exclusion>
+                    <groupId>org.apache.logging.log4j</groupId>
+                    <artifactId>log4j-slf4j-impl</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+
+
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>

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

@@ -145,195 +145,36 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
             Double addScore = difficulty_percent[difficulty - 1] * studentScores.get(questionId);
             //增加能力树总分,注意，每个competency都会加分
             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;
-                    }
-                }
-                if (!existCom1) {
-                    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<>();
-
-                    changeKSD1.setCompetency(com1);
-                    changeKSD1.setTotalScore(0.0);
-                    changeKSD1.setSkillsAndScores(addS);
-                    changeKSD1.setDScore(addD);
-                    changeKSD1.setChildren(addChild);
-                }
-
-                //处理该层的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;
+            
+            for(int i=0;i<knowledgeList.size();i++){
+                String[] coms = knowledgeList.get(i).split("\\.");
+                String com1 = coms[0];
+                dfs(subTree,disposition,weight,addScore,"",com1);
+                int index1 = 0;
+                if(coms.length > 1){
+                    String com2 = coms[1];
+                    for(;index1<subTree.size();index1++){
+                        if(subTree.get(index1).getCompetency().equals(com1)){
                             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 (!existCom1) {
-                    subTree.add(changeKSD1);
+                    dfs(subTree.get(index1).getChildren(),disposition,weight,addScore,com1+".",com2);
                 }
-
-                //如果有子层需要处理
-                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;
+                if(coms.length > 2){
+                    String com2 = coms[1];
+                    String com3 = coms[2];
+//                    System.out.println(com1+com2+com3);
+                    int index2 = 0;
+                    for(;index2<subTree.get(index1).getChildren().size();index2++){
+//                        System.out.println(subTree.get(index1).getChildren().get(index2).getCompetency());
+                        if(subTree.get(index1).getChildren().get(index2).getCompetency().split("\\.")[1].equals(com2)){
                             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);
-                    }
-
-                    //如果有子层需要处理
-                    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);
-                        }
-                    }
+                    dfs(subTree.get(index1).getChildren().get(index2).getChildren(),disposition,weight,addScore,com1+"."+com2+".",com3);
                 }
             }
+
         }
 
         //处理完考试中的每个问题后，更新能力树
@@ -344,6 +185,71 @@ public class EvalDataAnalysisServiceImpl implements EvalDataAnalysisService {
         return competencyTree;
     }
 
+    public void dfs(List<KSDScore> sub,String disposition,Integer weight,Double addScore,String pre,String com){
+//        System.out.println("start: "+com);
+        boolean existCom = false;
+        KSDScore changeKSD = new KSDScore();
+        for (KSDScore ksdScore : sub) {
+            System.out.println(ksdScore.getCompetency());
+            if (ksdScore.getCompetency().equals(pre+com)) {
+                existCom = true;
+                changeKSD = ksdScore;
+                break;
+            }
+        }
+        if (!existCom) {
+            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<>();
+
+            changeKSD.setCompetency(pre+com);
+            changeKSD.setTotalScore(0.0);
+            changeKSD.setSkillsAndScores(addS);
+            changeKSD.setDScore(addD);
+            changeKSD.setChildren(addChild);
+        }
+        Double totalScore = changeKSD.getTotalScore();
+        totalScore += addScore;
+        changeKSD.setTotalScore(totalScore);
+        //增加Skills
+        List<Double> skillsAndScore = changeKSD.getSkillsAndScores();
+        Double skillScore = skillsAndScore.get(weight-1);
+        skillScore += addScore;
+        skillsAndScore.set(weight-1,skillScore);
+        changeKSD.setSkillsAndScores(skillsAndScore);
+        //增加Disposition
+        if(disposition != null){
+            boolean existD = false;
+            List<DScore> subD = changeKSD.getDScore();
+            DScore changeD = new DScore();
+            for (DScore dScore : subD) {
+                if (dScore.getName().equals(disposition)) {
+                    existD = true;
+                    changeD = dScore;
+                    break;
+                }
+            }
+            if (!existD) {
+                changeD.setName(disposition);
+                changeD.setScore(0.0);
+            }
+            Double addDScore = addScore + changeD.getScore();
+            changeD.setScore(addDScore);
+            //需要增加新建的D子分支
+            if (!existD) {
+                subD.add(changeD);
+            }
+            changeKSD.setDScore(subD);
+        }else {
+            System.out.println("disposition信息不存在");
+        }
+
+        if (!existCom) {
+            sub.add(changeKSD);
+        }
+    }
+
     @Override
     public Map<String, Double> getStudentErrorQuestions(int userId){
         List<EvalExamRecord> evalExamRecordList = evalExamRecordDao.findByUserId(userId);

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

@@ -1,11 +1,16 @@
 package com.seecoder.dataanalysis.data.entity.competency;
 
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.experimental.Accessors;
 
+import java.io.*;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 /**
@@ -16,90 +21,173 @@ import java.util.List;
 @Data
 public class Competencies{
 
-    /**
-     * 能力名称
-     */
-    List<String> competency;
+//    /**
+//     * 能力名称
+//     */
+//    List<String> competency;
+//
+//    /**
+//     * 能力子分支
+//     */
+//    List<String[]> sub_competency;
 
     /**
-     * 能力子分支
+     * 预先指定的知识点knowledge
      */
-    List<String[]> sub_competency;
+    List<String> knowledges;
 
     /**
      * 预先指定的disposition
      */
     List<String> dispositions;
 
-    public Competencies(){
-        List<String> competencyNameList = new ArrayList<>();
-        List<String[]> subCom = new ArrayList<>();
-
-        String[] sub1 = new String[]{"软件设计基础","软件体系结构","软件设计符号","软件设计策略与方法","软件设计的关键问题","软件设计工具"};
-        competencyNameList.add("软件设计");
-        subCom.add(sub1);
-
-        String[] sub2 = new String[]{"软件构造基础","管理软件构造","软件构造-实际考虑","构造技术","软件构造工具"};
-        competencyNameList.add("软件构造");
-        subCom.add(sub2);
-
-        String[] sub3 = new String[]{"软件维护基础","软件维护关键问题","维护过程","维护技术","软件维护工具"};
-        competencyNameList.add("软件维护");
-        subCom.add(sub3);
-
-        String[] sub4 = new String[]{"软件配置管理过程的管理","软甲配置标识","软件配置控制","软件配置状态核定","软件配置审计","软件发布管理与交付","软件配置管理工具"};
-        competencyNameList.add("软件配置管理");
-        subCom.add(sub4);
-
-        String[] sub5 = new String[]{"初始化和范围定义","软件项目规划","软件项目执行","审查和评估","结束","软件工程测量","软件工程管理工具"};
-        competencyNameList.add("软件工程管理");
-        subCom.add(sub5);
-
-        String[] sub6 = new String[]{"软件过程定义","软件生命周期","软件过程的评估和改进","软件度量","软件工程过程工具"};
-        competencyNameList.add("软件工程过程");
-        subCom.add(sub6);
-
-        String[] sub7 = new String[]{"建模方法","模型类型","模型分析","软件工程方法"};
-        competencyNameList.add("软件工程模型与方法");
-        subCom.add(sub7);
-
-        String[] sub8 = new String[]{"需求验证","软件需求-实际考虑","软件需求工具","软件需求基础","需求过程","需求捕获","需求分析","需求规约"};
-        competencyNameList.add("软件需求");
-        subCom.add(sub8);
+//    public Competencies(){
+//        List<String> competencyNameList = new ArrayList<>();
+//        List<String[]> subCom = new ArrayList<>();
+//
+//        String[] sub1 = new String[]{"软件设计基础","软件体系结构","软件设计符号","软件设计策略与方法","软件设计的关键问题","软件设计工具"};
+//        competencyNameList.add("软件设计");
+//        subCom.add(sub1);
+//
+//        String[] sub2 = new String[]{"软件构造基础","管理软件构造","软件构造-实际考虑","构造技术","软件构造工具"};
+//        competencyNameList.add("软件构造");
+//        subCom.add(sub2);
+//
+//        String[] sub3 = new String[]{"软件维护基础","软件维护关键问题","维护过程","维护技术","软件维护工具"};
+//        competencyNameList.add("软件维护");
+//        subCom.add(sub3);
+//
+//        String[] sub4 = new String[]{"软件配置管理过程的管理","软甲配置标识","软件配置控制","软件配置状态核定","软件配置审计","软件发布管理与交付","软件配置管理工具"};
+//        competencyNameList.add("软件配置管理");
+//        subCom.add(sub4);
+//
+//        String[] sub5 = new String[]{"初始化和范围定义","软件项目规划","软件项目执行","审查和评估","结束","软件工程测量","软件工程管理工具"};
+//        competencyNameList.add("软件工程管理");
+//        subCom.add(sub5);
+//
+//        String[] sub6 = new String[]{"软件过程定义","软件生命周期","软件过程的评估和改进","软件度量","软件工程过程工具"};
+//        competencyNameList.add("软件工程过程");
+//        subCom.add(sub6);
+//
+//        String[] sub7 = new String[]{"建模方法","模型类型","模型分析","软件工程方法"};
+//        competencyNameList.add("软件工程模型与方法");
+//        subCom.add(sub7);
+//
+//        String[] sub8 = new String[]{"需求验证","软件需求-实际考虑","软件需求工具","软件需求基础","需求过程","需求捕获","需求分析","需求规约"};
+//        competencyNameList.add("软件需求");
+//        subCom.add(sub8);
+//
+//        String[] sub9 = new String[]{"测试相关测量","测试过程","软件测试工具","软件测试基础","测试级别","测试技术"};
+//        competencyNameList.add("软件测试");
+//        subCom.add(sub9);
+//
+//        String[] sub10 = new String[]{"软件质量基础","软件质量管理过程","软件质量-实际考虑","软件质量工具"};
+//        competencyNameList.add("软件质量");
+//        subCom.add(sub10);
+//
+//        String[] sub11 = new String[]{"职业技能","团队动力与心理学","沟通技巧"};
+//        competencyNameList.add("软件工程职业实践");
+//        subCom.add(sub11);
+//
+//        String[] sub12 = new String[]{"软件工程经济学基础","生命周期经济学","风险与不确定性","经济分析方法","软件工程经济学-实际考虑"};
+//        competencyNameList.add("软件工程经济学");
+//        subCom.add(sub12);
+//
+//        String[] sub13 = new String[]{"问题求解技巧","抽象化","程序设计基础","编程语言基础知识","调试工具和技巧","数据结构和数据表示","算法及其复杂性","系统的基本概念","计算机组织","编译基础","操作系统基础","数据库基础知识","网络通信基础","并行和分布式计算","基本用户的人因素","基础开发者的人因素","安全软件开发和维护"};
+//        competencyNameList.add("计算基础");
+//        subCom.add(sub13);
+//
+//        String[] sub14 = new String[]{"集合、关系、函数","逻辑基础","证明技巧","计数基础","图和数","离散概率","有限状态机","文法","数值精度、准确性、误差","数论","代数结构"};
+//        competencyNameList.add("数学基础");
+//        subCom.add(sub14);
+//
+//        String[] sub15 = new String[]{"实证方法与实验技术","统计分析","测量","工程设计","建模、仿真与原型","标准","根本原因"};
+//        competencyNameList.add("工程基础");
+//        subCom.add(sub15);
+//
+//        String[] dis = new String[]{"细心","专注度","热情","责任心"};
+//        List<String> disList = Arrays.asList(dis);
+//
+//        this.competency = competencyNameList;
+//        this.sub_competency = subCom;
+//        this.dispositions = disList;
+//    }
 
-        String[] sub9 = new String[]{"测试相关测量","测试过程","软件测试工具","软件测试基础","测试级别","测试技术"};
-        competencyNameList.add("软件测试");
-        subCom.add(sub9);
-
-        String[] sub10 = new String[]{"软件质量基础","软件质量管理过程","软件质量-实际考虑","软件质量工具"};
-        competencyNameList.add("软件质量");
-        subCom.add(sub10);
-
-        String[] sub11 = new String[]{"职业技能","团队动力与心理学","沟通技巧"};
-        competencyNameList.add("软件工程职业实践");
-        subCom.add(sub11);
-
-        String[] sub12 = new String[]{"软件工程经济学基础","生命周期经济学","风险与不确定性","经济分析方法","软件工程经济学-实际考虑"};
-        competencyNameList.add("软件工程经济学");
-        subCom.add(sub12);
-
-        String[] sub13 = new String[]{"问题求解技巧","抽象化","程序设计基础","编程语言基础知识","调试工具和技巧","数据结构和数据表示","算法及其复杂性","系统的基本概念","计算机组织","编译基础","操作系统基础","数据库基础知识","网络通信基础","并行和分布式计算","基本用户的人因素","基础开发者的人因素","安全软件开发和维护"};
-        competencyNameList.add("计算基础");
-        subCom.add(sub13);
-
-        String[] sub14 = new String[]{"集合、关系、函数","逻辑基础","证明技巧","计数基础","图和数","离散概率","有限状态机","文法","数值精度、准确性、误差","数论","代数结构"};
-        competencyNameList.add("数学基础");
-        subCom.add(sub14);
-
-        String[] sub15 = new String[]{"实证方法与实验技术","统计分析","测量","工程设计","建模、仿真与原型","标准","根本原因"};
-        competencyNameList.add("工程基础");
-        subCom.add(sub15);
+    public Competencies(){
+        String path = "src/main/resources/knowledgeId.json";
+        String s = readJsonFile(path);
+        JSONObject jsonObject = JSON.parseObject(s);
+        JSONArray knowledges = jsonObject.getJSONArray("KNOWLEDGES");
+        List<String> knowledgeAbbr = new ArrayList<>();
+        for(int i=0;i<knowledges.size();i++){
+            JSONObject key = (JSONObject)knowledges.get(i);
+//            System.out.println((String)key.get("id"));
+            knowledgeAbbr.add((String)key.get("abbreviation"));
+//            System.out.println((String)key.get("abbreviation"));
+//            System.out.println((String)key.get("name"));
+        }
+        Collections.sort(knowledgeAbbr);
+        Collections.sort(knowledgeAbbr,(a,b) -> countPoint(b) - countPoint(a));
+        List<String> after = new ArrayList<>();
+        after.add(knowledgeAbbr.get(0));
+        int index=1;
+        for(;index<knowledgeAbbr.size();index++){
+            if(countPoint(knowledgeAbbr.get(index))==countPoint(knowledgeAbbr.get(index-1))){
+                after.add(knowledgeAbbr.get(index));
+            }else {
+                break;
+            }
+        }
+        for(;index<knowledgeAbbr.size();index++){
+            boolean overlap = false;
+            for(String have : after){
+                if(have.contains(knowledgeAbbr.get(index))){
+                    overlap = true;
+                    break;
+                }
+            }
+            if(!overlap){
+                after.add(knowledgeAbbr.get(index));
+            }
+        }
+//        for(String str : after){
+//            System.out.println(str);
+//        }
+
+        this.knowledges = after;
+        this.dispositions = Arrays.asList(new String[]{"热情","专注"});
+    }
 
-        String[] dis = new String[]{"细心","专注度","热情","责任心"};
-        List<String> disList = Arrays.asList(dis);
+    //计算字符串中.(分隔符)的数目
+    int countPoint(String s){
+        int count = 0;
+        for(int i=0;i<s.length();i++){
+            if(s.charAt(i) == '.'){
+                count++;
+            }
+        }
+        return count;
+    }
 
-        this.competency = competencyNameList;
-        this.sub_competency = subCom;
-        this.dispositions = disList;
+    public String readJsonFile(String fileName){
+        String jsonStr = "";
+        try{
+            File jsonFile = new File(fileName);
+            FileReader fileReader = new FileReader(jsonFile);
+            Reader reader = new InputStreamReader(new FileInputStream(jsonFile),"utf-8");
+            int ch = 0;
+            StringBuffer sb = new StringBuffer();
+            while((ch = reader.read())!=-1){
+                sb.append((char)ch);
+            }
+            fileReader.close();
+            reader.close();
+            jsonStr = sb.toString();
+            return jsonStr;
+        }catch (IOException e){
+            e.printStackTrace();
+            return null;
+        }
     }
+
 }

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

@@ -50,61 +50,162 @@ public class CompetencyTree {
     }
 
     /**
-     * 生成初始化好的能力树，用于可视化结果返回
+     * 根据传入的参数，生成初始化好的能力树，用于可视化结果返回
+     * @param competencies
      * @return CompetencyTree 初始化好的能力树
      */
     public CompetencyTree(Competencies competencies){
-        CompetencyTree competencyTree = new CompetencyTree();
-        List<String> comName = competencies.getCompetency();
-        List<String[]> subComName = competencies.getSub_competency();
-        List<String> disName = competencies.getDispositions();
-
+//        CompetencyTree competencyTree = new CompetencyTree();
+//        List<String> comName = competencies.getCompetency();
+//        List<String[]> subComName = competencies.getSub_competency();
+//        List<String> disName = competencies.getDispositions();
+//
+//        this.userId = -1;
+//        this.treeScore = 0.0;
+////        competencyTree.setUserId(-1);
+////        competencyTree.setTreeScore(0.0);
+//        List<KSDScore> ksdScoreList = new ArrayList<>();
+//        //为每个大分支新建KSDScore
+//        for(int i=0;i<comName.size();i++){
+//            KSDScore ksdScore = new KSDScore();
+//            String com = comName.get(i);
+//            String[] subs = subComName.get(i);
+//
+//            ksdScore.setCompetency(com);
+//            ksdScore.setTotalScore(0.0);
+//
+//            List<KSScore> ksScoreList = new ArrayList<>();
+//            //为每个小分支新建KSScore
+//            for(int j=0;j<subs.length;j++){
+//                KSScore ksScore = new KSScore();
+//                String sub = subs[j];
+//                ksScore.setKnowledge(sub);
+//                Double[] doubles = new Double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+//                ksScore.setSkillsAndScore(Arrays.asList(doubles));
+//
+//                ksScoreList.add(ksScore);
+//            }
+//
+//            //为每个大分支新建DScore
+//            List<DScore> dScoreList = new ArrayList<>();
+//            for(int j=0;j<disName.size();j++){
+//                DScore dScore = new DScore();
+//                dScore.setName(disName.get(j));
+//                dScore.setScore(0.0);
+//
+//                dScoreList.add(dScore);
+//            }
+//
+////            ksdScore.setKSScore(ksScoreList);
+//            ksdScore.setDScore(dScoreList);
+//
+//            ksdScoreList.add(ksdScore);
+//        }
+//
+////        competencyTree.setSubCompetencyTree(ksdScoreList);
+//        this.subCompetencyTree = ksdScoreList;
+        List<String> knowledges = competencies.getKnowledges();
+        List<String> dispositions = competencies.getDispositions();
         this.userId = -1;
         this.treeScore = 0.0;
-//        competencyTree.setUserId(-1);
-//        competencyTree.setTreeScore(0.0);
-        List<KSDScore> ksdScoreList = new ArrayList<>();
-        //为每个大分支新建KSDScore
-        for(int i=0;i<comName.size();i++){
-            KSDScore ksdScore = new KSDScore();
-            String com = comName.get(i);
-            String[] subs = subComName.get(i);
-
-            ksdScore.setCompetency(com);
-            ksdScore.setTotalScore(0.0);
-
-            List<KSScore> ksScoreList = new ArrayList<>();
-            //为每个小分支新建KSScore
-            for(int j=0;j<subs.length;j++){
-                KSScore ksScore = new KSScore();
-                String sub = subs[j];
-                ksScore.setKnowledge(sub);
-                Double[] doubles = new Double[]{0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
-                ksScore.setSkillsAndScore(Arrays.asList(doubles));
-
-                ksScoreList.add(ksScore);
+        this.subCompetencyTree = new ArrayList<>();
+
+        for(int i=0;i<knowledges.size();i++){
+            String[] coms = knowledges.get(i).split("\\.");
+            String com1 = coms[0];
+            dfs(this.subCompetencyTree,dispositions,"",com1);
+            int index1 = 0;
+            if(coms.length > 1){
+                String com2 = coms[1];
+                for(;index1<this.subCompetencyTree.size();index1++){
+                    if(this.subCompetencyTree.get(index1).getCompetency().equals(com1)){
+                        break;
+                    }
+                }
+                dfs(this.subCompetencyTree.get(index1).getChildren(),dispositions,com1+".",com2);
+            }
+            if(coms.length > 2){
+                String com2 = coms[1];
+                String com3 = coms[2];
+                int index2 = 0;
+                for(;index2<this.subCompetencyTree.get(index1).getChildren().size();index2++){
+                    if(this.subCompetencyTree.get(index1).getChildren().get(index2).getCompetency().split("\\.")[1].equals(com2)){
+                        break;
+                    }
+                }
+                dfs(this.subCompetencyTree.get(index1).getChildren().get(index2).getChildren(),dispositions,com1+"."+com2+".",com3);
             }
+        }
 
-            //为每个大分支新建DScore
-            List<DScore> dScoreList = new ArrayList<>();
-            for(int j=0;j<disName.size();j++){
-                DScore dScore = new DScore();
-                dScore.setName(disName.get(j));
-                dScore.setScore(0.0);
+//        System.out.println(this.subCompetencyTree.get(1));
+////        System.out.println(this.subCompetencyTree.get(1).getChildren().size());
+////        for(KSDScore ksdScore : this.subCompetencyTree.get(1).getChildren()){
+////            System.out.println(ksdScore.getCompetency());
+////        }
+//        System.out.println(this.subCompetencyTree.get(1).getChildren().get(0));
+//        for(KSDScore ksdScore : this.subCompetencyTree.get(1).getChildren().get(0).getChildren()){
+//            System.out.println(ksdScore.getCompetency());
+//        }
+////        System.out.println(this.subCompetencyTree.get(1).getChildren().get(0).getChildren().size());
+////        System.out.println(this.subCompetencyTree.size());
+    }
 
-                dScoreList.add(dScore);
+    public void dfs(List<KSDScore> sub,List<String> dis,String pre,String com){
+        boolean existCom = false;
+        KSDScore changeKSD = new KSDScore();
+        for (KSDScore ksdScore : sub) {
+            if (ksdScore.getCompetency().equals(pre+com)) {
+                existCom = true;
+                changeKSD = ksdScore;
+                break;
             }
+        }
+        if (!existCom) {
+            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<>();
+
+//            String total = pre+"";
+            changeKSD.setCompetency(pre+com);
+            changeKSD.setTotalScore(0.0);
+            changeKSD.setSkillsAndScores(addS);
+            changeKSD.setDScore(addD);
+            changeKSD.setChildren(addChild);
+        }
 
-//            ksdScore.setKSScore(ksScoreList);
-            ksdScore.setDScore(dScoreList);
+        if(dis!=null&&dis.size()>0){
+            for(String disposition : dis){
+                boolean existD = false;
+                List<DScore> subD = changeKSD.getDScore();
+                DScore changeD = new DScore();
+                for (DScore dScore : subD) {
+                    if (dScore.getName().equals(disposition)) {
+                        existD = true;
+                        changeD = dScore;
+                        break;
+                    }
+                }
+                if (!existD) {
+                    changeD.setName(disposition);
+                    changeD.setScore(0.0);
+                }
+                //需要增加新建的D子分支
+                if (!existD) {
+                    subD.add(changeD);
+                }
+                changeKSD.setDScore(subD);
+            }
+        }else {
+            System.out.println("disposition信息不存在");
+        }
 
-            ksdScoreList.add(ksdScore);
+        if (!existCom) {
+            sub.add(changeKSD);
         }
+    }
 
-//        competencyTree.setSubCompetencyTree(ksdScoreList);
-        this.subCompetencyTree = ksdScoreList;
 
-    }
 
     public void display(){
         System.out.println(this.userId);

src/main/java/com/seecoder/dataanalysis/logic/question/Impl/QuestionServiceImpl.java

@@ -5,9 +5,11 @@ import cn.seecoder.bok.common.vo.QuestionVO;
 import com.seecoder.dataanalysis.data.entity.eval.Question;
 import com.seecoder.dataanalysis.logic.question.QuestionService;
 import com.seecoder.dataanalysis.vo.question.CompleteQuestionVO;
+import org.apache.kafka.common.protocol.types.Field;
 import org.springframework.beans.BeanUtils;
 import org.springframework.stereotype.Service;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
@@ -22,13 +24,21 @@ public class QuestionServiceImpl implements QuestionService {
             System.out.println("不存在该题目");
         }
         System.out.println(response.get());
-        System.out.println();
+//        System.out.println();
         CompleteQuestionVO res = new CompleteQuestionVO();
+//        String[] testArray = new String[]{"SR.RV.RT"};
+//        res.setKnowledgeId(Arrays.asList(testArray));
         response.ifPresent(questionVO -> BeanUtils.copyProperties(questionVO, res));
-        System.out.println(res);
+//        System.out.println(res);
 
-        Question question = new Question();
-        question.setQuestionId("123");
+        Question question = new Question(res);
+        for(String s : question.getCompetencies()) {
+            System.out.println(s);
+//            String[] cs = s.split("\\.");
+//            for(String s1 : cs){
+//                System.out.println(s1);
+//            }
+        }
         return question;
     }
 }

src/main/java/com/seecoder/dataanalysis/logic/question/QuestionService.java

@@ -0,0 +1,12 @@
+package com.seecoder.dataanalysis.logic.question;
+
+import com.seecoder.dataanalysis.data.entity.eval.Question;
+
+public interface QuestionService {
+    /**
+     * 调用第三方题库，从题库获得题目相关信息
+     * @param questionId
+     * @return Question
+     */
+    Question getQuestionById(String questionId);
+}

src/main/resources/knowledgeId.json

@@ -0,0 +1,3140 @@
+{
+	"KNOWLEDGES":[
+    {
+        "id": "0",
+        "abbreviation": "SR.RS.SoftwareRS",
+        "name": "软件需求规约",
+        "nameEng": null,
+        "parentId": "485",
+        "parentName": "需求规约"
+    },
+    {
+        "id": "1",
+        "abbreviation": "SR.RV",
+        "name": "需求验证",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "20",
+        "abbreviation": "SR.RV.RR",
+        "name": "需求评审",
+        "nameEng": null,
+        "parentId": "1",
+        "parentName": "需求验证"
+    },
+    {
+        "id": "21",
+        "abbreviation": "SR.RV.P",
+        "name": "原型法",
+        "nameEng": null,
+        "parentId": "1",
+        "parentName": "需求验证"
+    },
+    {
+        "id": "22",
+        "abbreviation": "SR.RV.MV",
+        "name": "模型验证",
+        "nameEng": null,
+        "parentId": "1",
+        "parentName": "需求验证"
+    },
+    {
+        "id": "23",
+        "abbreviation": "SR.RV.AT",
+        "name": "接受性测试",
+        "nameEng": null,
+        "parentId": "1",
+        "parentName": "需求验证"
+    },
+    {
+        "id": "24",
+        "abbreviation": "SR.RC",
+        "name": "软件需求-实际考虑",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "25",
+        "abbreviation": "SR.RC.INRP",
+        "name": "需求过程的迭代本质",
+        "nameEng": null,
+        "parentId": "24",
+        "parentName": "软件需求-实际考虑"
+    },
+    {
+        "id": "26",
+        "abbreviation": "SR.RC.CM",
+        "name": "变更管理",
+        "nameEng": null,
+        "parentId": "24",
+        "parentName": "软件需求-实际考虑"
+    },
+    {
+        "id": "27",
+        "abbreviation": "SR.RC.RA",
+        "name": "需求属性",
+        "nameEng": null,
+        "parentId": "24",
+        "parentName": "软件需求-实际考虑"
+    },
+    {
+        "id": "28",
+        "abbreviation": "SR.RC.RT",
+        "name": "需求追踪",
+        "nameEng": null,
+        "parentId": "24",
+        "parentName": "软件需求-实际考虑"
+    },
+    {
+        "id": "29",
+        "abbreviation": "SR.RC.MR",
+        "name": "度量需求",
+        "nameEng": null,
+        "parentId": "24",
+        "parentName": "软件需求-实际考虑"
+    },
+    {
+        "id": "30",
+        "abbreviation": "SR.SRT",
+        "name": "软件需求工具",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "31",
+        "abbreviation": "SD",
+        "name": "软件设计",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "32",
+        "abbreviation": "SD.SDF",
+        "name": "软件设计基础",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "33",
+        "abbreviation": "SD.SDF.GDC",
+        "name": "通用设计概念",
+        "nameEng": null,
+        "parentId": "32",
+        "parentName": "软件设计基础"
+    },
+    {
+        "id": "34",
+        "abbreviation": "SD.SDF.CSD",
+        "name": "软件设计情境",
+        "nameEng": null,
+        "parentId": "32",
+        "parentName": "软件设计基础"
+    },
+    {
+        "id": "35",
+        "abbreviation": "SD.SDF.SDProcess",
+        "name": "软件设计过程",
+        "nameEng": null,
+        "parentId": "32",
+        "parentName": "软件设计基础"
+    },
+    {
+        "id": "36",
+        "abbreviation": "SD.SDF.SDPrinciples",
+        "name": "软件设计原理",
+        "nameEng": null,
+        "parentId": "32",
+        "parentName": "软件设计基础"
+    },
+    {
+        "id": "37",
+        "abbreviation": "SD.SSA",
+        "name": "软件体系结构",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "38",
+        "abbreviation": "SD.SSA.ASV",
+        "name": "体系结构的结构与视图",
+        "nameEng": null,
+        "parentId": "37",
+        "parentName": "软件体系结构"
+    },
+    {
+        "id": "39",
+        "abbreviation": "SD.SSA.AS",
+        "name": "体系结构的风格",
+        "nameEng": null,
+        "parentId": "37",
+        "parentName": "软件体系结构"
+    },
+    {
+        "id": "40",
+        "abbreviation": "SD.SSA.DP",
+        "name": "设计模式",
+        "nameEng": null,
+        "parentId": "37",
+        "parentName": "软件体系结构"
+    },
+    {
+        "id": "41",
+        "abbreviation": "SD.SSA.ADD",
+        "name": "体系结构设计决策",
+        "nameEng": null,
+        "parentId": "37",
+        "parentName": "软件体系结构"
+    },
+    {
+        "id": "42",
+        "abbreviation": "SD.SSA.FPF",
+        "name": "程序族与架构",
+        "nameEng": null,
+        "parentId": "37",
+        "parentName": "软件体系结构"
+    },
+    {
+        "id": "43",
+        "abbreviation": "SD.SDN",
+        "name": "软件设计符号",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "44",
+        "abbreviation": "SD.SDN.BDSV",
+        "name": "结构化描述（静态视图）",
+        "nameEng": null,
+        "parentId": "43",
+        "parentName": "软件设计符号"
+    },
+    {
+        "id": "45",
+        "abbreviation": "SD.SDN.BDDV",
+        "name": "行为描述（动态视图）",
+        "nameEng": null,
+        "parentId": "43",
+        "parentName": "软件设计符号"
+    },
+    {
+        "id": "46",
+        "abbreviation": "SD.SDSM",
+        "name": "软件设计策略与方法",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "47",
+        "abbreviation": "SD.SDSM.GS",
+        "name": "软件设计的通用策略",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "48",
+        "abbreviation": "SD.SDSM.FOSD",
+        "name": "面向功能的（结构化的）设计",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "49",
+        "abbreviation": "SD.SDSM.OOD",
+        "name": "面向对象的设计",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "50",
+        "abbreviation": "SD.SDSM.DSCD",
+        "name": "以数据结构为中心的设计",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "51",
+        "abbreviation": "SD.SDSM.CBD",
+        "name": "基于组件的设计",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "52",
+        "abbreviation": "SD.SDSM.OM",
+        "name": "其他设计策略和方法",
+        "nameEng": null,
+        "parentId": "46",
+        "parentName": "软件设计策略与方法"
+    },
+    {
+        "id": "53",
+        "abbreviation": "SD.KISD",
+        "name": "软件设计的关键问题",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "54",
+        "abbreviation": "SD.KISD.C",
+        "name": "并发性",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "55",
+        "abbreviation": "SD.KISD.CHE",
+        "name": "事件的控制与处理",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "56",
+        "abbreviation": "SD.KISD.DP",
+        "name": "数据持久性",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "57",
+        "abbreviation": "SD.KISD.DC",
+        "name": "组件的分布",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "58",
+        "abbreviation": "SD.KISD.EEHFT",
+        "name": "错误、异常处理与容错",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "59",
+        "abbreviation": "SD.KISD.IP",
+        "name": "交互与表现",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "60",
+        "abbreviation": "SD.KISD.S",
+        "name": "安全性",
+        "nameEng": null,
+        "parentId": "53",
+        "parentName": "软件设计的关键问题"
+    },
+    {
+        "id": "61",
+        "abbreviation": "SD.SDT",
+        "name": "软件设计工具",
+        "nameEng": null,
+        "parentId": "31",
+        "parentName": "软件设计"
+    },
+    {
+        "id": "62",
+        "abbreviation": "SC",
+        "name": "软件构造",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "63",
+        "abbreviation": "SC.SCF",
+        "name": "软件构造基础",
+        "nameEng": null,
+        "parentId": "62",
+        "parentName": "软件构造"
+    },
+    {
+        "id": "64",
+        "abbreviation": "SC.SCF.MC",
+        "name": "最小化复杂性",
+        "nameEng": null,
+        "parentId": "63",
+        "parentName": "软件构造基础"
+    },
+    {
+        "id": "65",
+        "abbreviation": "SC.SCF.AC",
+        "name": "预测变更",
+        "nameEng": null,
+        "parentId": "63",
+        "parentName": "软件构造基础"
+    },
+    {
+        "id": "66",
+        "abbreviation": "SC.SCF.CV",
+        "name": "为验证而构造",
+        "nameEng": null,
+        "parentId": "63",
+        "parentName": "软件构造基础"
+    },
+    {
+        "id": "67",
+        "abbreviation": "SC.SCF.R",
+        "name": "复用",
+        "nameEng": null,
+        "parentId": "63",
+        "parentName": "软件构造基础"
+    },
+    {
+        "id": "68",
+        "abbreviation": "SC.SCF.SC",
+        "name": "构造标准",
+        "nameEng": null,
+        "parentId": "63",
+        "parentName": "软件构造基础"
+    },
+    {
+        "id": "69",
+        "abbreviation": "SC.MC",
+        "name": "管理软件构造",
+        "nameEng": null,
+        "parentId": "62",
+        "parentName": "软件构造"
+    },
+    {
+        "id": "70",
+        "abbreviation": "SC.MC.CLCM",
+        "name": "生命周期模型中的构造",
+        "nameEng": null,
+        "parentId": "69",
+        "parentName": "管理软件构造"
+    },
+    {
+        "id": "71",
+        "abbreviation": "SC.MC.CP",
+        "name": "构造规划",
+        "nameEng": null,
+        "parentId": "69",
+        "parentName": "管理软件构造"
+    },
+    {
+        "id": "72",
+        "abbreviation": "SC.MC.CM",
+        "name": "构造度量",
+        "nameEng": null,
+        "parentId": "69",
+        "parentName": "管理软件构造"
+    },
+    {
+        "id": "73",
+        "abbreviation": "SC.PC",
+        "name": "软件构造-实际考虑",
+        "nameEng": null,
+        "parentId": "62",
+        "parentName": "软件构造"
+    },
+    {
+        "id": "74",
+        "abbreviation": "SC.PC.CD",
+        "name": "构造设计",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "75",
+        "abbreviation": "SC.PC.CL",
+        "name": "构造语言",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "76",
+        "abbreviation": "SC.PC.C",
+        "name": "代码编写",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "77",
+        "abbreviation": "SC.PC.CT",
+        "name": "构造测试",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "78",
+        "abbreviation": "SC.PC.CforR",
+        "name": "面向复用的构造",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "79",
+        "abbreviation": "SC.PC.CwithR",
+        "name": "基于复用的构造",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "80",
+        "abbreviation": "SC.PC.CQ",
+        "name": "构造质量",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "81",
+        "abbreviation": "SC.PC.I",
+        "name": "集成",
+        "nameEng": null,
+        "parentId": "73",
+        "parentName": "软件构造-实际考虑"
+    },
+    {
+        "id": "82",
+        "abbreviation": "SC.CT",
+        "name": "构造技术",
+        "nameEng": null,
+        "parentId": "62",
+        "parentName": "软件构造"
+    },
+    {
+        "id": "83",
+        "abbreviation": "SC.CT.ADU",
+        "name": "API设计与应用",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "84",
+        "abbreviation": "SC.CT.OORI",
+        "name": "面向对象的运行态问题",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "85",
+        "abbreviation": "SC.CT.PG",
+        "name": "参数化与泛化",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "86",
+        "abbreviation": "SC.CT.ADCDP",
+        "name": "断言、契约式设计、防御式编程",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "87",
+        "abbreviation": "SC.CT.EHEHFT",
+        "name": "错误处理、异常处理与容错",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "88",
+        "abbreviation": "SC.CT.EM",
+        "name": "可执行模型",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "89",
+        "abbreviation": "SC.CT.SBTDCT",
+        "name": "基于状态和表驱动的构造技术",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "90",
+        "abbreviation": "SC.CT.RCI",
+        "name": "运行态配置与国际化",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "91",
+        "abbreviation": "SC.CT.GBIP",
+        "name": "基于语法的输入处理",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "92",
+        "abbreviation": "SC.CT.CP",
+        "name": "并发源语",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "93",
+        "abbreviation": "SC.CT.M",
+        "name": "中间件",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "94",
+        "abbreviation": "SC.CT.CMDS",
+        "name": "分布式软件构造方法",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "95",
+        "abbreviation": "SC.CT.CHS",
+        "name": "构造异构系统",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "96",
+        "abbreviation": "SC.CT.PAT",
+        "name": "性能分析与代码调整",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "97",
+        "abbreviation": "SC.CT.PS",
+        "name": "平台标准",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "98",
+        "abbreviation": "SC.CT.TFP",
+        "name": "测试优先的编程",
+        "nameEng": null,
+        "parentId": "82",
+        "parentName": "构造技术"
+    },
+    {
+        "id": "99",
+        "abbreviation": "SC.SCT",
+        "name": "软件构造工具",
+        "nameEng": null,
+        "parentId": "62",
+        "parentName": "软件构造"
+    },
+    {
+        "id": "100",
+        "abbreviation": "SC.SCT.DE",
+        "name": "软件开发环境",
+        "nameEng": null,
+        "parentId": "99",
+        "parentName": "软件构造工具"
+    },
+    {
+        "id": "101",
+        "abbreviation": "SC.SCT.GUI",
+        "name": "GUI构造器",
+        "nameEng": null,
+        "parentId": "99",
+        "parentName": "软件构造工具"
+    },
+    {
+        "id": "102",
+        "abbreviation": "SC.SCT.UTT",
+        "name": "单元测试工具",
+        "nameEng": null,
+        "parentId": "99",
+        "parentName": "软件构造工具"
+    },
+    {
+        "id": "118",
+        "abbreviation": "ST.TT.TBNA",
+        "name": "基于应用性质的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "119",
+        "abbreviation": "ST.TT.SCT",
+        "name": "测试技术的选择与组合",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "120",
+        "abbreviation": "ST.TRM",
+        "name": "测试相关测量",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "121",
+        "abbreviation": "ST.TRM.EPUT",
+        "name": "测试中的程序评价",
+        "nameEng": null,
+        "parentId": "120",
+        "parentName": "测试相关测量"
+    },
+    {
+        "id": "122",
+        "abbreviation": "ST.TRM.ETP",
+        "name": "测试执行的评价",
+        "nameEng": null,
+        "parentId": "120",
+        "parentName": "测试相关测量"
+    },
+    {
+        "id": "123",
+        "abbreviation": "ST.TP",
+        "name": "测试过程",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "124",
+        "abbreviation": "ST.TP.PC",
+        "name": "测试过程-实际考虑",
+        "nameEng": null,
+        "parentId": "123",
+        "parentName": "测试过程"
+    },
+    {
+        "id": "125",
+        "abbreviation": "ST.TP.TA",
+        "name": "测试活动",
+        "nameEng": null,
+        "parentId": "123",
+        "parentName": "测试过程"
+    },
+    {
+        "id": "126",
+        "abbreviation": "ST.STT",
+        "name": "软件测试工具",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "127",
+        "abbreviation": "ST.STT.TTS",
+        "name": "测试支持工具",
+        "nameEng": null,
+        "parentId": "126",
+        "parentName": "软件测试工具"
+    },
+    {
+        "id": "128",
+        "abbreviation": "ST.STT.CT",
+        "name": "测试工具分类",
+        "nameEng": null,
+        "parentId": "126",
+        "parentName": "软件测试工具"
+    },
+    {
+        "id": "129",
+        "abbreviation": "SM",
+        "name": "软件维护",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "130",
+        "abbreviation": "SM.SMF",
+        "name": "软件维护基础",
+        "nameEng": null,
+        "parentId": "129",
+        "parentName": "软件维护"
+    },
+    {
+        "id": "131",
+        "abbreviation": "SM.SMF.DT",
+        "name": "定义和术语",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "132",
+        "abbreviation": "SM.SMF.NatureM",
+        "name": "软件维护的本质",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "133",
+        "abbreviation": "SM.SMF.NeedM",
+        "name": "软件维护的需要",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "134",
+        "abbreviation": "SM.SMF.MMC",
+        "name": "主要维护成本",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "135",
+        "abbreviation": "SM.SMF.ES",
+        "name": "软件演化",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "136",
+        "abbreviation": "SM.SMF.CM",
+        "name": "软件维护分类",
+        "nameEng": null,
+        "parentId": "130",
+        "parentName": "软件维护基础"
+    },
+    {
+        "id": "137",
+        "abbreviation": "SM.KISM",
+        "name": "软件维护关键问题",
+        "nameEng": null,
+        "parentId": "129",
+        "parentName": "软件维护"
+    },
+    {
+        "id": "138",
+        "abbreviation": "SM.KISM.TI",
+        "name": "技术问题",
+        "nameEng": null,
+        "parentId": "137",
+        "parentName": "软件维护关键问题"
+    },
+    {
+        "id": "139",
+        "abbreviation": "SM.KISM.MI",
+        "name": "管理问题",
+        "nameEng": null,
+        "parentId": "137",
+        "parentName": "软件维护关键问题"
+    },
+    {
+        "id": "140",
+        "abbreviation": "SM.KISM.MCE",
+        "name": "维护成本预估",
+        "nameEng": null,
+        "parentId": "137",
+        "parentName": "软件维护关键问题"
+    },
+    {
+        "id": "141",
+        "abbreviation": "SM.KISM.SMM",
+        "name": "软件维护度量",
+        "nameEng": null,
+        "parentId": "137",
+        "parentName": "软件维护关键问题"
+    },
+    {
+        "id": "142",
+        "abbreviation": "SM.MP",
+        "name": "维护过程",
+        "nameEng": null,
+        "parentId": "129",
+        "parentName": "软件维护"
+    },
+    {
+        "id": "143",
+        "abbreviation": "SM.MP.MP",
+        "name": "维护过程-维护过程",
+        "nameEng": null,
+        "parentId": "142",
+        "parentName": "维护过程"
+    },
+    {
+        "id": "144",
+        "abbreviation": "SM.MP.MA",
+        "name": "维护活动",
+        "nameEng": null,
+        "parentId": "142",
+        "parentName": "维护过程"
+    },
+    {
+        "id": "145",
+        "abbreviation": "SM.TM",
+        "name": "维护技术",
+        "nameEng": null,
+        "parentId": "129",
+        "parentName": "软件维护"
+    },
+    {
+        "id": "146",
+        "abbreviation": "SM.TM.PC",
+        "name": "程序理解",
+        "nameEng": null,
+        "parentId": "145",
+        "parentName": "维护技术"
+    },
+    {
+        "id": "147",
+        "abbreviation": "SM.TM.Reengineering",
+        "name": "再工程",
+        "nameEng": null,
+        "parentId": "145",
+        "parentName": "维护技术"
+    },
+    {
+        "id": "148",
+        "abbreviation": "SM.TM.RE",
+        "name": "逆向工程",
+        "nameEng": null,
+        "parentId": "145",
+        "parentName": "维护技术"
+    },
+    {
+        "id": "149",
+        "abbreviation": "SM.TM.M",
+        "name": "迁移",
+        "nameEng": null,
+        "parentId": "145",
+        "parentName": "维护技术"
+    },
+    {
+        "id": "150",
+        "abbreviation": "SM.TM.Retirement",
+        "name": "软件退役",
+        "nameEng": null,
+        "parentId": "145",
+        "parentName": "维护技术"
+    },
+    {
+        "id": "151",
+        "abbreviation": "SM.SMT",
+        "name": "软件维护工具",
+        "nameEng": null,
+        "parentId": "129",
+        "parentName": "软件维护"
+    },
+    {
+        "id": "152",
+        "abbreviation": "SCM",
+        "name": "软件配置管理",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "153",
+        "abbreviation": "SCM.MSP",
+        "name": "软件配置管理过程的管理",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "154",
+        "abbreviation": "SCM.MSP.QCS",
+        "name": "软件配置管理组织情景",
+        "nameEng": null,
+        "parentId": "153",
+        "parentName": "软件配置管理过程的管理"
+    },
+    {
+        "id": "155",
+        "abbreviation": "SCM.MSP.CGSP",
+        "name": "软件配置管理过程约束与指南",
+        "nameEng": null,
+        "parentId": "153",
+        "parentName": "软件配置管理过程的管理"
+    },
+    {
+        "id": "156",
+        "abbreviation": "SCM.MSP.PS",
+        "name": "软件配置管理规划",
+        "nameEng": null,
+        "parentId": "153",
+        "parentName": "软件配置管理过程的管理"
+    },
+    {
+        "id": "157",
+        "abbreviation": "SCM.MSP.SP",
+        "name": "软件配置管理文档",
+        "nameEng": null,
+        "parentId": "153",
+        "parentName": "软件配置管理过程的管理"
+    },
+    {
+        "id": "158",
+        "abbreviation": "SCM.MSP.SS",
+        "name": "软件配置管理监督",
+        "nameEng": null,
+        "parentId": "153",
+        "parentName": "软件配置管理过程的管理"
+    },
+    {
+        "id": "159",
+        "abbreviation": "SCM.SCI",
+        "name": "软件配置标识",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "160",
+        "abbreviation": "SCM.SCI.IIC",
+        "name": "识别受控制项",
+        "nameEng": null,
+        "parentId": "159",
+        "parentName": "软件配置标识"
+    },
+    {
+        "id": "161",
+        "abbreviation": "SCM.SCI.SL",
+        "name": "软件库",
+        "nameEng": null,
+        "parentId": "159",
+        "parentName": "软件配置标识"
+    },
+    {
+        "id": "162",
+        "abbreviation": "SCM.SCC",
+        "name": "软件配置控制",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "163",
+        "abbreviation": "SCM.SCC.REASC",
+        "name": "请求、评价与批准软件变更",
+        "nameEng": null,
+        "parentId": "162",
+        "parentName": "软件配置控制"
+    },
+    {
+        "id": "164",
+        "abbreviation": "SCM.SCC.ISC",
+        "name": "实施软件变更",
+        "nameEng": null,
+        "parentId": "162",
+        "parentName": "软件配置控制"
+    },
+    {
+        "id": "165",
+        "abbreviation": "SCM.SCC.DW",
+        "name": "偏离与弃权",
+        "nameEng": null,
+        "parentId": "162",
+        "parentName": "软件配置控制"
+    },
+    {
+        "id": "166",
+        "abbreviation": "SCM.SCSA",
+        "name": "软件配置状态核定",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "167",
+        "abbreviation": "SCM.SCSA.SCSI",
+        "name": "软件配置状态信息",
+        "nameEng": null,
+        "parentId": "166",
+        "parentName": "软件配置状态核定"
+    },
+    {
+        "id": "168",
+        "abbreviation": "SCM.SCSA.SCSR",
+        "name": "软件配置状态报告",
+        "nameEng": null,
+        "parentId": "166",
+        "parentName": "软件配置状态核定"
+    },
+    {
+        "id": "169",
+        "abbreviation": "SCM.SCA",
+        "name": "软件配置审计",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "170",
+        "abbreviation": "SCM.SCA.SFCA",
+        "name": "软件功能配置审计",
+        "nameEng": null,
+        "parentId": "169",
+        "parentName": "软件配置审计"
+    },
+    {
+        "id": "171",
+        "abbreviation": "SCM.SCA.SPCA",
+        "name": "软件物理配置审计",
+        "nameEng": null,
+        "parentId": "169",
+        "parentName": "软件配置审计"
+    },
+    {
+        "id": "172",
+        "abbreviation": "SCM.SCA.IPASB",
+        "name": "软件基线的过程内审计",
+        "nameEng": null,
+        "parentId": "169",
+        "parentName": "软件配置审计"
+    },
+    {
+        "id": "173",
+        "abbreviation": "SCM.SRMD",
+        "name": "软件发布管理与交付",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "174",
+        "abbreviation": "SCM.SRMD.SB",
+        "name": "软件发布管理与交付-软件构造",
+        "nameEng": null,
+        "parentId": "173",
+        "parentName": "软件发布管理与交付"
+    },
+    {
+        "id": "175",
+        "abbreviation": "SCM.SRMD.SRM",
+        "name": "软件发布管理",
+        "nameEng": null,
+        "parentId": "173",
+        "parentName": "软件发布管理与交付"
+    },
+    {
+        "id": "176",
+        "abbreviation": "SCM.SCMT",
+        "name": "软件配置管理工具",
+        "nameEng": null,
+        "parentId": "152",
+        "parentName": "软件配置管理"
+    },
+    {
+        "id": "177",
+        "abbreviation": "SEM",
+        "name": "软件工程管理",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "178",
+        "abbreviation": "SEM.ISD",
+        "name": "初始化和范围定义",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "179",
+        "abbreviation": "SEM.ISD.DNR",
+        "name": "需求协商和确定",
+        "nameEng": null,
+        "parentId": "178",
+        "parentName": "初始化和范围定义"
+    },
+    {
+        "id": "180",
+        "abbreviation": "SEM.ISD.FA",
+        "name": "可行性的分析",
+        "nameEng": null,
+        "parentId": "178",
+        "parentName": "初始化和范围定义"
+    },
+    {
+        "id": "181",
+        "abbreviation": "SEM.ISD.PRRR",
+        "name": "需求审查和修订的流程",
+        "nameEng": null,
+        "parentId": "178",
+        "parentName": "初始化和范围定义"
+    },
+    {
+        "id": "182",
+        "abbreviation": "SEM.SPP",
+        "name": "软件项目规划",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "183",
+        "abbreviation": "SEM.SPP.PP",
+        "name": "过程设计",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "184",
+        "abbreviation": "SEM.SPP.DD",
+        "name": "确定可交付软件构件",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "185",
+        "abbreviation": "SEM.SPP.ESCE",
+        "name": "成果、时间表和成本估计",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "186",
+        "abbreviation": "SEM.SPP.RA",
+        "name": "资源分配",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "187",
+        "abbreviation": "SEM.SPP.RM",
+        "name": "风险管理",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "188",
+        "abbreviation": "SEM.SPP.QM",
+        "name": "质量管理",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "189",
+        "abbreviation": "SEM.SPP.PM",
+        "name": "计划管理",
+        "nameEng": null,
+        "parentId": "182",
+        "parentName": "软件项目规划"
+    },
+    {
+        "id": "190",
+        "abbreviation": "SEM.SPE",
+        "name": "软件项目执行",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "191",
+        "abbreviation": "SEM.SPE.IP",
+        "name": "设计实施",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "192",
+        "abbreviation": "SEM.SPE.SASCM",
+        "name": "软件供需合同管理",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "193",
+        "abbreviation": "SEM.SPE.IMP",
+        "name": "测量过程实施",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "194",
+        "abbreviation": "SEM.SPE.MP",
+        "name": "监控过程",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "195",
+        "abbreviation": "SEM.SPE.CP",
+        "name": "过程控制",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "196",
+        "abbreviation": "SEM.SPE.R",
+        "name": "报告",
+        "nameEng": null,
+        "parentId": "190",
+        "parentName": "软件项目执行"
+    },
+    {
+        "id": "197",
+        "abbreviation": "SEM.RE",
+        "name": "审查和评估",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "198",
+        "abbreviation": "SEM.RE.DSR",
+        "name": "需求满意度的判定",
+        "nameEng": null,
+        "parentId": "197",
+        "parentName": "审查和评估"
+    },
+    {
+        "id": "199",
+        "abbreviation": "SEM.RE.REP",
+        "name": "审查和评估的表现",
+        "nameEng": null,
+        "parentId": "197",
+        "parentName": "审查和评估"
+    },
+    {
+        "id": "200",
+        "abbreviation": "SEM.C",
+        "name": "结束",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "201",
+        "abbreviation": "SEM.C.DC",
+        "name": "结束判定",
+        "nameEng": null,
+        "parentId": "200",
+        "parentName": "结束"
+    },
+    {
+        "id": "202",
+        "abbreviation": "SEM.C.CA",
+        "name": "结束活动",
+        "nameEng": null,
+        "parentId": "200",
+        "parentName": "结束"
+    },
+    {
+        "id": "203",
+        "abbreviation": "SEM.SEMeasurement",
+        "name": "软件工程测量",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "204",
+        "abbreviation": "SEM.SEM.ESMC",
+        "name": "建立和维持测量义务",
+        "nameEng": null,
+        "parentId": "203",
+        "parentName": "软件工程测量"
+    },
+    {
+        "id": "205",
+        "abbreviation": "SEM.SEM.PlanMP",
+        "name": "规划测量过程",
+        "nameEng": null,
+        "parentId": "203",
+        "parentName": "软件工程测量"
+    },
+    {
+        "id": "206",
+        "abbreviation": "SEM.SEM.PerformMP",
+        "name": "执行测量过程",
+        "nameEng": null,
+        "parentId": "203",
+        "parentName": "软件工程测量"
+    },
+    {
+        "id": "207",
+        "abbreviation": "SEM.SEM.EM",
+        "name": "评估测量",
+        "nameEng": null,
+        "parentId": "203",
+        "parentName": "软件工程测量"
+    },
+    {
+        "id": "208",
+        "abbreviation": "SEM.SEM",
+        "name": "软件工程管理工具",
+        "nameEng": null,
+        "parentId": "177",
+        "parentName": "软件工程管理"
+    },
+    {
+        "id": "209",
+        "abbreviation": "SEP",
+        "name": "软件工程过程",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "210",
+        "abbreviation": "SEP.SPD",
+        "name": "软件过程定义",
+        "nameEng": null,
+        "parentId": "209",
+        "parentName": "软件工程过程"
+    },
+    {
+        "id": "211",
+        "abbreviation": "SEP.SPD.SPM",
+        "name": "软件过程管理",
+        "nameEng": null,
+        "parentId": "210",
+        "parentName": "软件过程定义"
+    },
+    {
+        "id": "212",
+        "abbreviation": "SEP.SPD.SPI",
+        "name": "软件过程基础设施",
+        "nameEng": null,
+        "parentId": "210",
+        "parentName": "软件过程定义"
+    },
+    {
+        "id": "213",
+        "abbreviation": "SEP.SLC",
+        "name": "软件生命周期",
+        "nameEng": null,
+        "parentId": "209",
+        "parentName": "软件工程过程"
+    },
+    {
+        "id": "214",
+        "abbreviation": "SEP.SLC.CSP",
+        "name": "软件过程分类",
+        "nameEng": null,
+        "parentId": "213",
+        "parentName": "软件生命周期"
+    },
+    {
+        "id": "215",
+        "abbreviation": "SEP.SLC.SLCM",
+        "name": "软件生命周期模型",
+        "nameEng": null,
+        "parentId": "213",
+        "parentName": "软件生命周期"
+    },
+    {
+        "id": "216",
+        "abbreviation": "SEP.SLC.SPA",
+        "name": "软件过程的适应",
+        "nameEng": null,
+        "parentId": "213",
+        "parentName": "软件生命周期"
+    },
+    {
+        "id": "217",
+        "abbreviation": "SEP.SLC.PC",
+        "name": "实际考虑因素",
+        "nameEng": null,
+        "parentId": "213",
+        "parentName": "软件生命周期"
+    },
+    {
+        "id": "218",
+        "abbreviation": "SEP.SPAI",
+        "name": "软件过程的评估和改进",
+        "nameEng": null,
+        "parentId": "209",
+        "parentName": "软件工程过程"
+    },
+    {
+        "id": "219",
+        "abbreviation": "SEP.SPAI.SPAModels",
+        "name": "软件过程评估模型",
+        "nameEng": null,
+        "parentId": "218",
+        "parentName": "软件过程的评估和改进"
+    },
+    {
+        "id": "238",
+        "abbreviation": "SEP.SPAI.CSSPR",
+        "name": "持续性和阶段性软件过程评级",
+        "nameEng": null,
+        "parentId": "218",
+        "parentName": "软件过程的评估和改进"
+    },
+    {
+        "id": "239",
+        "abbreviation": "SEP.SM",
+        "name": "软件度量",
+        "nameEng": null,
+        "parentId": "209",
+        "parentName": "软件工程过程"
+    },
+    {
+        "id": "240",
+        "abbreviation": "SEP.SM.SPPM",
+        "name": "软件过程和产品的度量",
+        "nameEng": null,
+        "parentId": "239",
+        "parentName": "软件度量"
+    },
+    {
+        "id": "241",
+        "abbreviation": "SEP.SM.QMR",
+        "name": "度量结果的质量",
+        "nameEng": null,
+        "parentId": "239",
+        "parentName": "软件度量"
+    },
+    {
+        "id": "242",
+        "abbreviation": "SEP.SM.SIM",
+        "name": "软件信息模型",
+        "nameEng": null,
+        "parentId": "239",
+        "parentName": "软件度量"
+    },
+    {
+        "id": "243",
+        "abbreviation": "SEP.SM.SPMT",
+        "name": "软件过程度量技术",
+        "nameEng": null,
+        "parentId": "239",
+        "parentName": "软件度量"
+    },
+    {
+        "id": "244",
+        "abbreviation": "SEP.SEPT",
+        "name": "软件工程过程工具",
+        "nameEng": null,
+        "parentId": "209",
+        "parentName": "软件工程过程"
+    },
+    {
+        "id": "245",
+        "abbreviation": "SEMM",
+        "name": "软件工程模型与方法",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "246",
+        "abbreviation": "SEMM.M",
+        "name": "建模方法",
+        "nameEng": null,
+        "parentId": "245",
+        "parentName": "软件工程模型与方法"
+    },
+    {
+        "id": "247",
+        "abbreviation": "SEMM.M.MP",
+        "name": "建模原则",
+        "nameEng": null,
+        "parentId": "246",
+        "parentName": "建模方法"
+    },
+    {
+        "id": "248",
+        "abbreviation": "SEMM.M.PEM",
+        "name": "模型属性与表示",
+        "nameEng": null,
+        "parentId": "246",
+        "parentName": "建模方法"
+    },
+    {
+        "id": "249",
+        "abbreviation": "SEMM.M.SSP",
+        "name": "语法、语义和语用",
+        "nameEng": null,
+        "parentId": "246",
+        "parentName": "建模方法"
+    },
+    {
+        "id": "250",
+        "abbreviation": "SEMM.M.PPI",
+        "name": "前置条件、后置条件和不变量",
+        "nameEng": null,
+        "parentId": "246",
+        "parentName": "建模方法"
+    },
+    {
+        "id": "251",
+        "abbreviation": "SEMM.TM",
+        "name": "模型类型",
+        "nameEng": null,
+        "parentId": "245",
+        "parentName": "软件工程模型与方法"
+    },
+    {
+        "id": "252",
+        "abbreviation": "SEMM.TM.IM",
+        "name": "信息模型",
+        "nameEng": null,
+        "parentId": "251",
+        "parentName": "模型类型"
+    },
+    {
+        "id": "253",
+        "abbreviation": "SEMM.TM.BM",
+        "name": "行为模型",
+        "nameEng": null,
+        "parentId": "251",
+        "parentName": "模型类型"
+    },
+    {
+        "id": "254",
+        "abbreviation": "SEMM.TM.SM",
+        "name": "结构模型",
+        "nameEng": null,
+        "parentId": "251",
+        "parentName": "模型类型"
+    },
+    {
+        "id": "255",
+        "abbreviation": "SEMM.AM",
+        "name": "模型分析",
+        "nameEng": null,
+        "parentId": "245",
+        "parentName": "软件工程模型与方法"
+    },
+    {
+        "id": "256",
+        "abbreviation": "SEMM.AM.ACompleteness",
+        "name": "完整性分析",
+        "nameEng": null,
+        "parentId": "255",
+        "parentName": "模型分析"
+    },
+    {
+        "id": "257",
+        "abbreviation": "SEMM.AM.AConsistency",
+        "name": "一致性分析",
+        "nameEng": null,
+        "parentId": "255",
+        "parentName": "模型分析"
+    },
+    {
+        "id": "258",
+        "abbreviation": "SEMM.AM.Correctness",
+        "name": "正确性分析",
+        "nameEng": null,
+        "parentId": "255",
+        "parentName": "模型分析"
+    },
+    {
+        "id": "259",
+        "abbreviation": "SEMM.AM.T",
+        "name": "可追溯性分析",
+        "nameEng": null,
+        "parentId": "255",
+        "parentName": "模型分析"
+    },
+    {
+        "id": "260",
+        "abbreviation": "SEMM.AM.IA",
+        "name": "交互性分析",
+        "nameEng": null,
+        "parentId": "255",
+        "parentName": "模型分析"
+    },
+    {
+        "id": "261",
+        "abbreviation": "SEMM.SEM",
+        "name": "软件工程方法",
+        "nameEng": null,
+        "parentId": "245",
+        "parentName": "软件工程模型与方法"
+    },
+    {
+        "id": "262",
+        "abbreviation": "SR",
+        "name": "软件需求",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "263",
+        "abbreviation": "SE",
+        "name": "软件工程",
+        "nameEng": null,
+        "parentId": "435",
+        "parentName": "root"
+    },
+    {
+        "id": "264",
+        "abbreviation": "SR.SRF",
+        "name": "软件需求基础",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "265",
+        "abbreviation": "SR.SRF.DSR",
+        "name": "软件需求的定义",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "266",
+        "abbreviation": "SR.SRF.PPR",
+        "name": "产品与过程需求",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "267",
+        "abbreviation": "SR.SRF.FNR",
+        "name": "功能与非功能需求",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "268",
+        "abbreviation": "SR.SRF.EP",
+        "name": "突发需求",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "269",
+        "abbreviation": "SR.SRF.QR",
+        "name": "可量化需求",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "270",
+        "abbreviation": "SR.SRF.SRSR",
+        "name": "系统需求与软件需求",
+        "nameEng": null,
+        "parentId": "264",
+        "parentName": "软件需求基础"
+    },
+    {
+        "id": "271",
+        "abbreviation": "SR.RP",
+        "name": "需求过程",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "272",
+        "abbreviation": "SR.RP.PM",
+        "name": "过程模型",
+        "nameEng": null,
+        "parentId": "271",
+        "parentName": "需求过程"
+    },
+    {
+        "id": "273",
+        "abbreviation": "SC.SCT.PPAST",
+        "name": "性能分析工具",
+        "nameEng": null,
+        "parentId": "99",
+        "parentName": "软件构造工具"
+    },
+    {
+        "id": "274",
+        "abbreviation": "ST",
+        "name": "软件测试",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "275",
+        "abbreviation": "SEP.SPAI.SPAMethods",
+        "name": "软件过程评估方法",
+        "nameEng": null,
+        "parentId": "218",
+        "parentName": "软件过程的评估和改进"
+    },
+    {
+        "id": "276",
+        "abbreviation": "SEP.SPAI.SPIM",
+        "name": "软件过程改进模型",
+        "nameEng": null,
+        "parentId": "218",
+        "parentName": "软件过程的评估和改进"
+    },
+    {
+        "id": "277",
+        "abbreviation": "SEMM.SEM.HM",
+        "name": "启发式方法",
+        "nameEng": null,
+        "parentId": "261",
+        "parentName": "软件工程方法"
+    },
+    {
+        "id": "278",
+        "abbreviation": "SEMM.SEM.FM",
+        "name": "形式化方法",
+        "nameEng": null,
+        "parentId": "261",
+        "parentName": "软件工程方法"
+    },
+    {
+        "id": "279",
+        "abbreviation": "SEMM.SEM.PM",
+        "name": "快速原型法",
+        "nameEng": null,
+        "parentId": "261",
+        "parentName": "软件工程方法"
+    },
+    {
+        "id": "280",
+        "abbreviation": "SEMM.SEM.AM",
+        "name": "敏捷开发方法",
+        "nameEng": null,
+        "parentId": "261",
+        "parentName": "软件工程方法"
+    },
+    {
+        "id": "288",
+        "abbreviation": "SEMM.SEM.EP",
+        "name": "模型驱动开发方法",
+        "nameEng": null,
+        "parentId": "261",
+        "parentName": "软件工程方法"
+    },
+    {
+        "id": "289",
+        "abbreviation": "SQ",
+        "name": "软件质量",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "290",
+        "abbreviation": "SQ.SQF",
+        "name": "软件质量基础",
+        "nameEng": null,
+        "parentId": "289",
+        "parentName": "软件质量"
+    },
+    {
+        "id": "291",
+        "abbreviation": "SQ.SQF.SECE",
+        "name": "软件工程文化和伦理",
+        "nameEng": null,
+        "parentId": "290",
+        "parentName": "软件质量基础"
+    },
+    {
+        "id": "292",
+        "abbreviation": "SQ.SQF.VCQ",
+        "name": "质量的价值和成本",
+        "nameEng": null,
+        "parentId": "290",
+        "parentName": "软件质量基础"
+    },
+    {
+        "id": "293",
+        "abbreviation": "SQ.SQF.MQC",
+        "name": "模型和质量特征",
+        "nameEng": null,
+        "parentId": "290",
+        "parentName": "软件质量基础"
+    },
+    {
+        "id": "294",
+        "abbreviation": "SQ.SQF.SQI",
+        "name": "软件质量改进",
+        "nameEng": null,
+        "parentId": "290",
+        "parentName": "软件质量基础"
+    },
+    {
+        "id": "295",
+        "abbreviation": "SQ.SQF.SC",
+        "name": "软件安全",
+        "nameEng": null,
+        "parentId": "290",
+        "parentName": "软件质量基础"
+    },
+    {
+        "id": "296",
+        "abbreviation": "SQ.SQMP",
+        "name": "软件质量管理过程",
+        "nameEng": null,
+        "parentId": "289",
+        "parentName": "软件质量"
+    },
+    {
+        "id": "297",
+        "abbreviation": "SQ.SQMP.SQA",
+        "name": "软件质量保证",
+        "nameEng": null,
+        "parentId": "296",
+        "parentName": "软件质量管理过程"
+    },
+    {
+        "id": "298",
+        "abbreviation": "SQ.SQMP.VV",
+        "name": "检验和确认",
+        "nameEng": null,
+        "parentId": "296",
+        "parentName": "软件质量管理过程"
+    },
+    {
+        "id": "299",
+        "abbreviation": "SQ.SQMP.RA",
+        "name": "复核和审核",
+        "nameEng": null,
+        "parentId": "296",
+        "parentName": "软件质量管理过程"
+    },
+    {
+        "id": "300",
+        "abbreviation": "SQ.PC",
+        "name": "软件质量-实际考虑",
+        "nameEng": null,
+        "parentId": "289",
+        "parentName": "软件质量"
+    },
+    {
+        "id": "301",
+        "abbreviation": "SQ.PC.SQR",
+        "name": "软件质量需求",
+        "nameEng": null,
+        "parentId": "300",
+        "parentName": "软件质量-实际考虑"
+    },
+    {
+        "id": "302",
+        "abbreviation": "SQ.PC.DC",
+        "name": "缺陷特征",
+        "nameEng": null,
+        "parentId": "300",
+        "parentName": "软件质量-实际考虑"
+    },
+    {
+        "id": "303",
+        "abbreviation": "SQ.PC.SQMT",
+        "name": "软件质量管理技术",
+        "nameEng": null,
+        "parentId": "300",
+        "parentName": "软件质量-实际考虑"
+    },
+    {
+        "id": "304",
+        "abbreviation": "SQ.PC.SQM",
+        "name": "软件质量测量",
+        "nameEng": null,
+        "parentId": "300",
+        "parentName": "软件质量-实际考虑"
+    },
+    {
+        "id": "305",
+        "abbreviation": "SQ.SQT",
+        "name": "软件质量工具",
+        "nameEng": null,
+        "parentId": "289",
+        "parentName": "软件质量"
+    },
+    {
+        "id": "306",
+        "abbreviation": "SEPP",
+        "name": "软件工程职业实践",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "307",
+        "abbreviation": "SEPP.P",
+        "name": "职业技能",
+        "nameEng": null,
+        "parentId": "306",
+        "parentName": "软件工程职业实践"
+    },
+    {
+        "id": "308",
+        "abbreviation": "SEPP.P.ACL",
+        "name": "鉴定，认证和许可",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "309",
+        "abbreviation": "SEPP.P.CEPC",
+        "name": "职业道德与行为",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "310",
+        "abbreviation": "SEPP.P.NRPS",
+        "name": "专业团队的本质和角色",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "311",
+        "abbreviation": "SEPP.P.NRPSES",
+        "name": "软件工程标准的本质和作用",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "312",
+        "abbreviation": "SEPP.P.EIS",
+        "name": "软件的经济效应",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "313",
+        "abbreviation": "SEPP.P.EC",
+        "name": "雇佣合同",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "314",
+        "abbreviation": "SEPP.P.LI",
+        "name": "法律问题",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "315",
+        "abbreviation": "SEPP.P.D",
+        "name": "文档工作",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "316",
+        "abbreviation": "SEPP.P.TA",
+        "name": "折中分析",
+        "nameEng": null,
+        "parentId": "307",
+        "parentName": "职业技能"
+    },
+    {
+        "id": "317",
+        "abbreviation": "SEPP.GDP",
+        "name": "团队动力与心理学",
+        "nameEng": null,
+        "parentId": "306",
+        "parentName": "软件工程职业实践"
+    },
+    {
+        "id": "318",
+        "abbreviation": "SEPP.GDP.DWT/G",
+        "name": "团队工作动力",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "319",
+        "abbreviation": "SEPP.GDP.IC",
+        "name": "个体认知",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "320",
+        "abbreviation": "SEPP.GDP.DPC",
+        "name": "处理问题复杂性",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "321",
+        "abbreviation": "SEPP.GDP.IS",
+        "name": "与利益各方沟通",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "322",
+        "abbreviation": "SEPP.GDP.DUA",
+        "name": "不确定性和模糊性处理",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "323",
+        "abbreviation": "SEPP.GDP.DME",
+        "name": "多文化环境处理",
+        "nameEng": null,
+        "parentId": "317",
+        "parentName": "团队动力与心理学"
+    },
+    {
+        "id": "324",
+        "abbreviation": "SEPP.CS",
+        "name": "沟通技巧",
+        "nameEng": null,
+        "parentId": "306",
+        "parentName": "软件工程职业实践"
+    },
+    {
+        "id": "325",
+        "abbreviation": "SEPP.CS.RUS",
+        "name": "阅读、理解和概括",
+        "nameEng": null,
+        "parentId": "324",
+        "parentName": "沟通技巧"
+    },
+    {
+        "id": "326",
+        "abbreviation": "SEPP.CS.W",
+        "name": "写作技巧",
+        "nameEng": null,
+        "parentId": "324",
+        "parentName": "沟通技巧"
+    },
+    {
+        "id": "327",
+        "abbreviation": "SEPP.CS.TGC",
+        "name": "团队沟通",
+        "nameEng": null,
+        "parentId": "324",
+        "parentName": "沟通技巧"
+    },
+    {
+        "id": "328",
+        "abbreviation": "SEPP.CS.PS",
+        "name": "表达技巧",
+        "nameEng": null,
+        "parentId": "324",
+        "parentName": "沟通技巧"
+    },
+    {
+        "id": "329",
+        "abbreviation": "SEE",
+        "name": "软件工程经济学",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "330",
+        "abbreviation": "SEE.SEEF",
+        "name": "软件工程经济学基础",
+        "nameEng": null,
+        "parentId": "329",
+        "parentName": "软件工程经济学"
+    },
+    {
+        "id": "331",
+        "abbreviation": "SEE.SEEF.F",
+        "name": "金融",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "332",
+        "abbreviation": "SEE.SEEF.A",
+        "name": "会计",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "333",
+        "abbreviation": "SEE.SEEF.C",
+        "name": "管控",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "334",
+        "abbreviation": "ST.STF",
+        "name": "软件测试基础",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "335",
+        "abbreviation": "ST.STF.TRT",
+        "name": "测试相关术语",
+        "nameEng": null,
+        "parentId": "334",
+        "parentName": "软件测试基础"
+    },
+    {
+        "id": "336",
+        "abbreviation": "ST.STF.KI",
+        "name": "软件测试关键问题",
+        "nameEng": null,
+        "parentId": "334",
+        "parentName": "软件测试基础"
+    },
+    {
+        "id": "337",
+        "abbreviation": "ST.STF.RTOA",
+        "name": "测试与其他活动的关系",
+        "nameEng": null,
+        "parentId": "334",
+        "parentName": "软件测试基础"
+    },
+    {
+        "id": "338",
+        "abbreviation": "ST.TL",
+        "name": "测试级别",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "339",
+        "abbreviation": "ST.TL.TTT",
+        "name": "测试对象",
+        "nameEng": null,
+        "parentId": "338",
+        "parentName": "测试级别"
+    },
+    {
+        "id": "340",
+        "abbreviation": "ST.TL.OT",
+        "name": "测试目标",
+        "nameEng": null,
+        "parentId": "338",
+        "parentName": "测试级别"
+    },
+    {
+        "id": "341",
+        "abbreviation": "ST.TT",
+        "name": "测试技术",
+        "nameEng": null,
+        "parentId": "274",
+        "parentName": "软件测试"
+    },
+    {
+        "id": "342",
+        "abbreviation": "ST.TT.BSEIE",
+        "name": "基于软件工程师直觉和经验的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "343",
+        "abbreviation": "ST.TT.IDBT",
+        "name": "基于输入域的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "344",
+        "abbreviation": "ST.TT.CBT",
+        "name": "基于代码的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "345",
+        "abbreviation": "ST.TT.FBT",
+        "name": "基于故障的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "346",
+        "abbreviation": "ST.TT.UBT",
+        "name": "基于使用的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "347",
+        "abbreviation": "ST.TT.MBT",
+        "name": "基于模型的测试",
+        "nameEng": null,
+        "parentId": "341",
+        "parentName": "测试技术"
+    },
+    {
+        "id": "348",
+        "abbreviation": "SEE.SEEF.CF",
+        "name": "现金流",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "349",
+        "abbreviation": "SEE.SEEF.DMP",
+        "name": "决策过程",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "350",
+        "abbreviation": "SEE.SEEF.V",
+        "name": "估价",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "351",
+        "abbreviation": "SEE.SEEF.I",
+        "name": "通货膨胀",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "352",
+        "abbreviation": "SEE.SEEF.D",
+        "name": "贬值",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "353",
+        "abbreviation": "SEE.SEEF.T",
+        "name": "税收",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "354",
+        "abbreviation": "SEE.SEEF.TVM",
+        "name": "货币的时间价值",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "355",
+        "abbreviation": "SEE.SEEF.Efficiency",
+        "name": "效率",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "356",
+        "abbreviation": "SEE.SEEF.Effectiveness",
+        "name": "有效性",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "357",
+        "abbreviation": "SEE.SEEF.P",
+        "name": "生产率",
+        "nameEng": null,
+        "parentId": "330",
+        "parentName": "软件工程经济学基础"
+    },
+    {
+        "id": "358",
+        "abbreviation": "SEE.LCE",
+        "name": "生命周期经济学",
+        "nameEng": null,
+        "parentId": "329",
+        "parentName": "软件工程经济学"
+    },
+    {
+        "id": "359",
+        "abbreviation": "SEE.LCE.Product",
+        "name": "产品",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "360",
+        "abbreviation": "SEE.LCE.Project",
+        "name": "项目",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "361",
+        "abbreviation": "SEE.LCE.Program",
+        "name": "程序",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "362",
+        "abbreviation": "SEE.LCE.Portfolio",
+        "name": "组合",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "363",
+        "abbreviation": "SEE.LCE.ProductLC",
+        "name": "产品生命周期",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "364",
+        "abbreviation": "SEE.LCE.ProjectLC",
+        "name": "项目生命周期",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "365",
+        "abbreviation": "SEE.LCE.Proposals",
+        "name": "提案",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "366",
+        "abbreviation": "SEE.LCE.ID",
+        "name": "投资决策",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "367",
+        "abbreviation": "SEE.LCE.PH",
+        "name": "规划区间",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "368",
+        "abbreviation": "SEE.LCE.PP",
+        "name": "价格和定价",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "369",
+        "abbreviation": "SEE.LCE.CC",
+        "name": "费用与成本",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "370",
+        "abbreviation": "SEE.LCE.PM",
+        "name": "性能测试",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "371",
+        "abbreviation": "SEE.LCE.EVM",
+        "name": "挣值管理",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "372",
+        "abbreviation": "SEE.LCE.TD",
+        "name": "结束决策",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "373",
+        "abbreviation": "SEE.LCE.RRD",
+        "name": "替换与退休决策",
+        "nameEng": null,
+        "parentId": "358",
+        "parentName": "生命周期经济学"
+    },
+    {
+        "id": "374",
+        "abbreviation": "SEE.RU",
+        "name": "风险与不确定性",
+        "nameEng": null,
+        "parentId": "329",
+        "parentName": "软件工程经济学"
+    },
+    {
+        "id": "375",
+        "abbreviation": "SEE.RU.GEP",
+        "name": "目标、评估与规划",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "376",
+        "abbreviation": "SEE.RU.ET",
+        "name": "评估技术",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "377",
+        "abbreviation": "SEE.RU.AU",
+        "name": "解决不确定性",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "378",
+        "abbreviation": "SEE.RU.P",
+        "name": "优先次序",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "379",
+        "abbreviation": "SEE.RU.DR",
+        "name": "风险情况下的决策",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "380",
+        "abbreviation": "SEE.RU.DU",
+        "name": "不确定情况下的决策",
+        "nameEng": null,
+        "parentId": "374",
+        "parentName": "风险与不确定性"
+    },
+    {
+        "id": "381",
+        "abbreviation": "SEE.EAM",
+        "name": "经济分析方法",
+        "nameEng": null,
+        "parentId": "329",
+        "parentName": "软件工程经济学"
+    },
+    {
+        "id": "382",
+        "abbreviation": "SEE.EAM.FPDA",
+        "name": "以盈利为目的的决策分析",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "383",
+        "abbreviation": "SEE.EAM.MARR",
+        "name": "最小可接受收益率",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "384",
+        "abbreviation": "SEE.EAM.RI",
+        "name": "投资回报率",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "385",
+        "abbreviation": "SEE.EAM.RCE",
+        "name": "已投资资本回报率",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "386",
+        "abbreviation": "SEE.EAM.CBA",
+        "name": "成本收益分析",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "387",
+        "abbreviation": "SEE.EAM.CEA",
+        "name": "成本效益分析",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "388",
+        "abbreviation": "SEE.EAM.BEA",
+        "name": "保本分析",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "389",
+        "abbreviation": "SEE.EAM.BC",
+        "name": "商业案例",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "390",
+        "abbreviation": "SEE.EAM.MAE",
+        "name": "多属性评价",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "391",
+        "abbreviation": "SEE.EAM.QA",
+        "name": "优化分析",
+        "nameEng": null,
+        "parentId": "381",
+        "parentName": "经济分析方法"
+    },
+    {
+        "id": "392",
+        "abbreviation": "SEE.PC",
+        "name": "软件工程经济学-实际考虑",
+        "nameEng": null,
+        "parentId": "329",
+        "parentName": "软件工程经济学"
+    },
+    {
+        "id": "393",
+        "abbreviation": "SEE.PC.TGEP",
+        "name": "“足够好”原则",
+        "nameEng": null,
+        "parentId": "392",
+        "parentName": "软件工程经济学-实际考虑"
+    },
+    {
+        "id": "394",
+        "abbreviation": "SEE.PC.FFE",
+        "name": "非摩擦经济",
+        "nameEng": null,
+        "parentId": "392",
+        "parentName": "软件工程经济学-实际考虑"
+    },
+    {
+        "id": "395",
+        "abbreviation": "SEE.PC.E",
+        "name": "生态系统",
+        "nameEng": null,
+        "parentId": "392",
+        "parentName": "软件工程经济学-实际考虑"
+    },
+    {
+        "id": "396",
+        "abbreviation": "SEE.PC.OO",
+        "name": "离岸和外包",
+        "nameEng": null,
+        "parentId": "392",
+        "parentName": "软件工程经济学-实际考虑"
+    },
+    {
+        "id": "397",
+        "abbreviation": "CF",
+        "name": "计算基础",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "398",
+        "abbreviation": "CF.PST",
+        "name": "问题求解技巧",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "399",
+        "abbreviation": "CF.A",
+        "name": "抽象化",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "400",
+        "abbreviation": "CF.PF",
+        "name": "程序设计基础",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "401",
+        "abbreviation": "CF.PLB",
+        "name": "编程语言基础知识",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "402",
+        "abbreviation": "CF.DTT",
+        "name": "调试工具和技巧",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "403",
+        "abbreviation": "CF.DSR",
+        "name": "数据结构和数据表示",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "404",
+        "abbreviation": "CF.AC",
+        "name": "算法及其复杂性",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "405",
+        "abbreviation": "CF.BCS",
+        "name": "系统的基本概念",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "406",
+        "abbreviation": "CF.CQ",
+        "name": "计算机组织",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "407",
+        "abbreviation": "CF.QSB",
+        "name": "编译基础",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "408",
+        "abbreviation": "CF.CB",
+        "name": "操作系统基础",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "409",
+        "abbreviation": "CF.DBDM",
+        "name": "数据库基础知识",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "410",
+        "abbreviation": "CF.NCB",
+        "name": "网络通信基础",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "411",
+        "abbreviation": "CF.PDC",
+        "name": "并行和分布式计算",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "412",
+        "abbreviation": "CF.BUHF",
+        "name": "基本用户的人因素",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "413",
+        "abbreviation": "CF.BDHF",
+        "name": "基础开发者的人因素",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "414",
+        "abbreviation": "CF.SSDM",
+        "name": "安全软件开发和维护",
+        "nameEng": null,
+        "parentId": "397",
+        "parentName": "计算基础"
+    },
+    {
+        "id": "415",
+        "abbreviation": "MF",
+        "name": "数学基础",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "416",
+        "abbreviation": "MF.SRF",
+        "name": "集合、关系、函数",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "417",
+        "abbreviation": "MF.BL",
+        "name": "逻辑基础",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "418",
+        "abbreviation": "MF.PT",
+        "name": "证明技巧",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "419",
+        "abbreviation": "MF.BC",
+        "name": "计数基础",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "420",
+        "abbreviation": "MF.GT",
+        "name": "图和数",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "421",
+        "abbreviation": "MF.DP",
+        "name": "离散概率",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "422",
+        "abbreviation": "MF.FSM",
+        "name": "有限状态机",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "423",
+        "abbreviation": "MF.G",
+        "name": "文法",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "424",
+        "abbreviation": "MF.NPAE",
+        "name": "数值精度、准确性、误差",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "425",
+        "abbreviation": "MF.NT",
+        "name": "数论",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "426",
+        "abbreviation": "MF.AS",
+        "name": "代数结构",
+        "nameEng": null,
+        "parentId": "415",
+        "parentName": "数学基础"
+    },
+    {
+        "id": "427",
+        "abbreviation": "EF",
+        "name": "工程基础",
+        "nameEng": null,
+        "parentId": "263",
+        "parentName": "软件工程"
+    },
+    {
+        "id": "428",
+        "abbreviation": "EF.EMET",
+        "name": "实证方法与实验技术",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "429",
+        "abbreviation": "EF.SA",
+        "name": "统计分析",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "430",
+        "abbreviation": "EF.M",
+        "name": "测量",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "431",
+        "abbreviation": "EF.ED",
+        "name": "工程设计",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "432",
+        "abbreviation": "EF.ESP",
+        "name": "建模、仿真与原型",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "433",
+        "abbreviation": "EF.S",
+        "name": "标准",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "434",
+        "abbreviation": "EF.RCA",
+        "name": "根本原因",
+        "nameEng": null,
+        "parentId": "427",
+        "parentName": "工程基础"
+    },
+    {
+        "id": "473",
+        "abbreviation": "SR.RP.PA",
+        "name": "过程参与者",
+        "nameEng": null,
+        "parentId": "271",
+        "parentName": "需求过程"
+    },
+    {
+        "id": "474",
+        "abbreviation": "SR.RP.SPM",
+        "name": "过程支持与管理",
+        "nameEng": null,
+        "parentId": "271",
+        "parentName": "需求过程"
+    },
+    {
+        "id": "475",
+        "abbreviation": "SR.RP.PQI",
+        "name": "过程管理与改进",
+        "nameEng": null,
+        "parentId": "271",
+        "parentName": "需求过程"
+    },
+    {
+        "id": "476",
+        "abbreviation": "SR.RE",
+        "name": "需求捕获",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "477",
+        "abbreviation": "SR.RE.RS",
+        "name": "需求来源",
+        "nameEng": null,
+        "parentId": "476",
+        "parentName": "需求捕获"
+    },
+    {
+        "id": "478",
+        "abbreviation": "SR.RE.ET",
+        "name": "捕获技术",
+        "nameEng": null,
+        "parentId": "476",
+        "parentName": "需求捕获"
+    },
+    {
+        "id": "479",
+        "abbreviation": "SR.RA",
+        "name": "需求分析",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "480",
+        "abbreviation": "SR.RA.RC",
+        "name": "需求分类",
+        "nameEng": null,
+        "parentId": "479",
+        "parentName": "需求分析"
+    },
+    {
+        "id": "481",
+        "abbreviation": "SR.RA.CM",
+        "name": "概念建模",
+        "nameEng": null,
+        "parentId": "479",
+        "parentName": "需求分析"
+    },
+    {
+        "id": "482",
+        "abbreviation": "SR.RA.ADRA",
+        "name": "体系结构设计与需求分类",
+        "nameEng": null,
+        "parentId": "479",
+        "parentName": "需求分析"
+    },
+    {
+        "id": "483",
+        "abbreviation": "SR.RA.RN",
+        "name": "需求协商",
+        "nameEng": null,
+        "parentId": "479",
+        "parentName": "需求分析"
+    },
+    {
+        "id": "484",
+        "abbreviation": "SR.RA.FA",
+        "name": "形式化分析",
+        "nameEng": null,
+        "parentId": "479",
+        "parentName": "需求分析"
+    },
+    {
+        "id": "485",
+        "abbreviation": "SR.RS",
+        "name": "需求规约",
+        "nameEng": null,
+        "parentId": "262",
+        "parentName": "软件需求"
+    },
+    {
+        "id": "486",
+        "abbreviation": "SR.RS.SDD",
+        "name": "系统定义文档",
+        "nameEng": null,
+        "parentId": "485",
+        "parentName": "需求规约"
+    },
+    {
+        "id": "487",
+        "abbreviation": "SR.RS.SystemRS",
+        "name": "系统需求规约",
+        "nameEng": null,
+        "parentId": "485",
+        "parentName": "需求规约"
+    }
+]
+}

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

@@ -75,6 +75,18 @@ public class EvalDataAnalysisServiceImplTest {
 //        questionDao.save(question3);
 //    }
 
+    @Test
+    void initCompetencies(){
+        Competencies competencies = new Competencies();
+    }
+
+    @Test
+    void initModelTree(){
+        Competencies competencies = new Competencies();
+        CompetencyTree competencyTree = new CompetencyTree(competencies);
+        competencyTreeDao.save(competencyTree);
+    }
+
     @Test
     void addExamInfo(){
         Question question1 = questionService.getQuestionById("43604f6f-f829-4aaf-ab97-47b99c20ede0");
@@ -240,13 +252,6 @@ public class EvalDataAnalysisServiceImplTest {
         }
     }
 
-    @Test
-    void testModelTree(){
-        Competencies competencies = new Competencies();
-        CompetencyTree model = new CompetencyTree(competencies);
-        model.display();
-//        competencyTreeDao.save(model);
-    }
 
     @Test
     void testGetTreeById(){

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

@@ -2,7 +2,6 @@ package com.seecoder.dataanalysis.question.impl;
 
 import cn.seecoder.bok.client.SeecoderBokClient;
 import cn.seecoder.bok.common.vo.QuestionVO;
-//import com.seecoder.dataanalysis.logic.question.QuestionService;
 import com.seecoder.dataanalysis.logic.question.QuestionService;
 import com.seecoder.dataanalysis.vo.question.CompleteQuestionVO;
 import org.junit.jupiter.api.Test;