Merge branch 'master' into innerDevelop

src/main/java/com/diagbot/facade/TestwordInfoFacade.java

@@ -0,0 +1,574 @@
+package com.diagbot.facade;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.diagbot.client.CRFServiceClient;
+import com.diagbot.dto.RetrievalDTO;
+import com.diagbot.dto.StandConvertCrfBatchDTO;
+import com.diagbot.dto.StandConvertCrfDTO;
+import com.diagbot.dto.WordCrfDTO;
+import com.diagbot.entity.Ann;
+import com.diagbot.entity.SymptomFeature;
+import com.diagbot.entity.SymptomFeatureList;
+import com.diagbot.entity.TestwordInfo;
+import com.diagbot.entity.TestwordRes;
+import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
+import com.diagbot.service.SymptomFeatureService;
+import com.diagbot.service.TestwordInfoService;
+import com.diagbot.service.TestwordResService;
+import com.diagbot.service.impl.TestwordInfoServiceImpl;
+import com.diagbot.util.CoreUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.RetrievalVO;
+import com.diagbot.vo.SearchData;
+import com.diagbot.vo.StandConvertCrfVO;
+import com.diagbot.vo.SymptomFeatureVO;
+import com.diagbot.vo.TestwordInfoVO;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @Author:zhoutg
+ * @time: 2020/7/29 15:03
+ */
+@Component
+public class TestwordInfoFacade extends TestwordInfoServiceImpl {
+
+    @Autowired
+    CRFServiceClient crfServiceClient;
+    @Autowired
+    TestwordResFacade testwordResFacade;
+    @Autowired
+    @Qualifier("testwordResServiceImpl")
+    TestwordResService testwordResService;
+    @Autowired
+    @Qualifier("testwordInfoServiceImpl")
+    TestwordInfoService testwordInfoService;
+    @Autowired
+    @Qualifier("symptomFeatureServiceImpl")
+    SymptomFeatureService symptomFeatureService;
+    @Autowired
+    TestFacade testFacade;
+    @Autowired
+    RetrievalFacade retrievalFacade;
+    @Autowired
+    CommonFacade commonFacade;
+    int getWordBatch = 100; // 每批次读取的数据行数
+    int standConverSize = 100000; // 标准词返回的数量
+
+    public Map getWord(TestwordInfoVO testwordInfoVO) {
+        Map<String, String> res = new LinkedHashMap<>();
+        Long start = System.currentTimeMillis();
+
+        // 症状标准词
+        List<String> symptomStand = getStandWord(9, standConverSize).getSymptomNames();
+        // 诊断标准词
+        List<String> diseaseStand = getStandWord(4, standConverSize).getDiseaseNames().stream().map(r -> r.getName()).collect(Collectors.toList());
+        // 药品标准词
+        List<String> drugStand = getStandWord(5, standConverSize).getDrugNames().stream().map(r -> r.getName()).collect(Collectors.toList());
+        // 手术标准词
+        List<String> operateStand = getStandWord(6, standConverSize).getOperationNames().stream().map(r -> r.getName()).collect(Collectors.toList());
+        // 化验套餐标准词
+        List<String> lisItem = getStandWord(1, standConverSize).getLisNames();
+        // 化验明细标准词
+        List<String> lisDetail = getStandWord(2, standConverSize).getLisDetailNames().stream().map(r -> r.getUniqueName()).collect(Collectors.toList());
+        // 化验标准词
+        List<String> lisStand = new ArrayList<>();
+        lisStand.addAll(lisItem);
+        lisStand.addAll(lisDetail);
+        // 查体标准词
+        List<String> vitalStand = getStandWord(10, standConverSize).getVitalNames();
+        // 辅检结果标准词
+        List<String> pacsResStand = new ArrayList<>();
+
+        // 模型处理数据
+        WordCrfDTO wordCrfDTO = new WordCrfDTO();
+        QueryWrapper queryWrapper = new QueryWrapper<TestwordInfo>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("is_deal", 0);
+        if (ListUtil.isNotEmpty(testwordInfoVO.getIdList())) {
+            queryWrapper.in("id", testwordInfoVO.getIdList());
+        }
+        if (ListUtil.isNotEmpty(testwordInfoVO.getTypeList())) {
+            queryWrapper.in("type", testwordInfoVO.getTypeList());
+        }
+        queryWrapper.orderByAsc("id");
+        List<TestwordInfo> testwordInfoList = this.page(new Page<>(1, getWordBatch), queryWrapper).getRecords();
+
+        while (ListUtil.isNotEmpty(testwordInfoList)) {
+            List<TestwordRes> insertRes = new ArrayList<>(); // 结果集
+
+            Set<String> symptomList = new LinkedHashSet<>();
+            Set<String> diseaseList = new LinkedHashSet<>();
+            Set<String> drugList = new LinkedHashSet<>();
+            Set<String> operateList = new LinkedHashSet<>();
+            Set<String> lisList = new LinkedHashSet<>();
+            Set<String> pacsResList = new LinkedHashSet<>();
+            Set<String> vitalList = new LinkedHashSet<>();
+            for (TestwordInfo bean : testwordInfoList) {
+                String text = bean.getText();
+                String type = bean.getType();
+                SearchData searchData = new SearchData();
+                try {
+                    switch (type) {
+                        case "主诉":
+                        case "现病史":
+                            searchData.setSymptom(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 临床表现
+                            CoreUtil.addSet(symptomList, CoreUtil.getName(wordCrfDTO.getPresentLabel().getClinicals()));
+                            // 诊断
+                            CoreUtil.addSet(diseaseList, CoreUtil.getName(wordCrfDTO.getPresentLabel().getDiags()));
+                            // 药品
+                            CoreUtil.addSet(drugList, CoreUtil.getName(wordCrfDTO.getPresentLabel().getMedicines()));
+                            // 手术
+                            CoreUtil.addSet(operateList, CoreUtil.getName(wordCrfDTO.getPresentLabel().getOperations()));
+                            // 化验
+                            CoreUtil.addSet(lisList, CoreUtil.getName(wordCrfDTO.getLis()));
+                            CoreUtil.addSet(lisList, getDetail(wordCrfDTO.getLis()));
+                            // 辅检
+                            CoreUtil.addSet(pacsResList, CoreUtil.getName(wordCrfDTO.getPacsLabel().getRes()));
+                            break;
+                        case "既往史":
+                            searchData.setPasts(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 诊断
+                            CoreUtil.addSet(diseaseList, CoreUtil.getName(wordCrfDTO.getPastLabel().getDiags()));
+                            // 药品
+                            CoreUtil.addSet(drugList, CoreUtil.getName(wordCrfDTO.getPastLabel().getMedicines()));
+                            // 手术
+                            CoreUtil.addSet(operateList, CoreUtil.getName(wordCrfDTO.getPastLabel().getOperations()));
+                            break;
+                        case "出院医嘱":
+                            searchData.setPasts(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 药品
+                            CoreUtil.addSet(drugList, CoreUtil.getName(wordCrfDTO.getPastLabel().getMedicines()));
+                            break;
+                        case "专科体格检查":
+                            searchData.setVital(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 查体
+                            CoreUtil.addSet(vitalList, CoreUtil.getNameAppendBodyVital(wordCrfDTO.getVitalLabel().getVitals()));
+                            CoreUtil.addSet(vitalList, CoreUtil.getNameAppendBodySymptom(wordCrfDTO.getVitalLabel().getClinicals()));
+                            break;
+                        case "辅助检查":
+                            searchData.setSymptom(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 化验
+                            CoreUtil.addSet(lisList, CoreUtil.getName(wordCrfDTO.getLis()));
+                            CoreUtil.addSet(lisList, getDetail(wordCrfDTO.getLis()));
+                            // 辅检
+                            CoreUtil.addSet(pacsResList, CoreUtil.getName(wordCrfDTO.getPacsLabel().getRes()));
+                            break;
+                        case "实验室检查":
+                            searchData.setSymptom(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 化验
+                            CoreUtil.addSet(lisList, CoreUtil.getName(wordCrfDTO.getLis()));
+                            CoreUtil.addSet(lisList, getDetail(wordCrfDTO.getLis()));
+                            break;
+                        case "影像学检查":
+                            searchData.setSymptom(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 辅检
+                            CoreUtil.addSet(pacsResList, CoreUtil.getName(wordCrfDTO.getPacsLabel().getRes()));
+                            break;
+                        case "初步诊断":
+                        case "修正诊断":
+                        case "术前诊断":
+                        case "术后诊断":
+                        case "术中诊断":
+                        case "出院诊断":
+                        case "补充诊断":
+                            searchData.setDiagString(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 诊断
+                            CoreUtil.addSet(diseaseList, CoreUtil.getName(wordCrfDTO.getDiag()));
+                            break;
+                        case "手术名称":
+                            searchData.setPasts(text);
+                            wordCrfDTO = commonFacade.crf_process(searchData);
+                            // 手术
+                            CoreUtil.addSet(operateList, CoreUtil.getName(wordCrfDTO.getPastLabel().getOperations()));
+                            break;
+                    }
+                } catch (Exception e) {
+                    log.error("提词出错，主键【" + bean.getId() + "】，" + e.getMessage());
+                }
+            }
+
+            // 处理症状
+            dealBusiness(symptomList, "症状", symptomStand, insertRes);
+            // 处理诊断
+            dealBusiness(diseaseList, "诊断", diseaseStand, insertRes);
+            // 处理药品
+            dealBusiness(drugList, "药品", drugStand, insertRes);
+            // 处理手术
+            dealBusiness(operateList, "手术", operateStand, insertRes);
+            // 处理查体
+            dealBusiness(vitalList, "查体", vitalStand, insertRes);
+            // 处理化验
+            dealBusiness(lisList, "化验", lisStand, insertRes);
+            // 处理辅检结果
+            dealBusiness(pacsResList, "辅检结果", pacsResStand, insertRes);
+
+            // 保存结果
+            if (ListUtil.isNotEmpty(insertRes)) {
+                testwordResService.saveBatch(insertRes);
+            }
+            // 更新处理标记
+            for (TestwordInfo testwordInfo : testwordInfoList) {
+                testwordInfo.setGmtModified(DateUtil.now());
+                testwordInfo.setIsDeal(1);
+            }
+            testwordInfoService.saveOrUpdateBatch(testwordInfoList);
+
+            // 获取下一批数据
+            testwordInfoList = this.page(new Page<>(1, getWordBatch), queryWrapper).getRecords();
+        }
+
+        long mid = System.currentTimeMillis();
+        res.put("提词耗时", (mid - start) / 1000.0 + "秒");
+        // 提词后同义词转换
+        wordConvert();
+        long end = System.currentTimeMillis();
+        res.put("同义词转换耗时", (end - mid) / 1000.0 + "秒");
+        return res;
+    }
+
+    public RetrievalDTO getStandWord(Integer type, Integer size) {
+        RetrievalVO retrievalVO = new RetrievalVO();
+        retrievalVO.setType(type);
+        retrievalVO.setInputStr("");
+        retrievalVO.setSize(size);
+        return retrievalFacade.getname(retrievalVO);
+    }
+
+    /**
+     * 处理业务
+     * @param list
+     * @param type
+     * @param standList
+     */
+    public void dealBusiness(Set<String> list, String type, List<String> standList, List<TestwordRes> insertRes) {
+         if (list != null && list.size() > 0) {
+            List<TestwordRes> testwordResList = testwordResFacade.list(new QueryWrapper<TestwordRes>()
+                    .eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("word", list)
+                    .eq("type", type)
+            );
+            // 剔除数据库已存在
+            removeWord(list, testwordResList);
+            // 剔除标准
+            list.removeAll(standList);
+            // 转换成实体类
+            List<TestwordRes> insert = stringConvertRes(list, type);
+            // 保存
+            if (ListUtil.isNotEmpty(insert)) {
+                insertRes.addAll(insert);
+            }
+        }
+    }
+
+    /**
+     * string转实体类
+     * @param stringList
+     * @param type
+     * @return
+     */
+    public List<TestwordRes> stringConvertRes(Set<String> stringList, String type) {
+        List<TestwordRes> res = new ArrayList<>();
+        Date date = DateUtil.now();
+        for (String s : stringList) {
+            TestwordRes testwordRes = new TestwordRes();
+            testwordRes.setWord(s);
+            testwordRes.setType(type);
+            testwordRes.setGmtCreate(date);
+            testwordRes.setGmtModified(date);
+            res.add(testwordRes);
+        }
+        return res;
+    }
+
+    /**
+     * 剔除数据库已存在的数据
+     * @param stringList
+     * @param testwordResList
+     */
+    public void removeWord(Set<String> stringList, List<TestwordRes> testwordResList) {
+        if (ListUtil.isEmpty(testwordResList)) {
+            return ;
+        }
+        Set<String> setList = testwordResList.stream().map(r -> r.getWord()).collect(Collectors.toSet());
+        stringList.removeAll(setList);
+    }
+
+    /**
+     * 同义词转换
+     */
+    public void wordConvert() {
+        QueryWrapper queryWrapper = new QueryWrapper<TestwordRes>()
+                .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("is_deal", 0)
+                .orderByAsc("id");
+        List<TestwordRes> testwordInfoList = testwordResService.page(new Page<>(1, 20), queryWrapper).getRecords();
+
+        while(ListUtil.isNotEmpty(testwordInfoList)) {
+            List<StandConvertCrfVO> convertCrfVOList = new ArrayList<>();
+            for (TestwordRes testwordRes : testwordInfoList) {
+                StandConvertCrfVO standConvertCrfVO = new StandConvertCrfVO();
+                standConvertCrfVO.setWord(testwordRes.getWord());
+                standConvertCrfVO.setNumber(3);
+                switch (testwordRes.getType()) {
+                    case "症状":
+                        standConvertCrfVO.setWord_type("symptom");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    case "诊断":
+                        standConvertCrfVO.setWord_type("disease");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    case "药品":
+                        standConvertCrfVO.setWord_type("drug");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    case "手术":
+                        standConvertCrfVO.setWord_type("operation");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    case "查体":
+                        standConvertCrfVO.setWord_type("vital");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    // case "辅检结果":
+                    //     standConvertCrfVO.setWord_type("pacs");
+                    //     convertCrfVOList.add(standConvertCrfVO);
+                    //     break;
+                    case "化验":
+                        standConvertCrfVO.setWord_type("lis");
+                        convertCrfVOList.add(standConvertCrfVO);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            StandConvertCrfBatchDTO standConvertCrfBatchDTO = testFacade.testStandConvertBatch(convertCrfVOList);
+            Date date = DateUtil.now();
+            for (TestwordRes testwordRes : testwordInfoList) {
+                switch (testwordRes.getType()) {
+                    case "症状":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "symptom");
+                        break;
+                    case "诊断":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "disease");
+                        break;
+                    case "药品":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "drug");
+                        break;
+                    case "手术":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "operation");
+                        break;
+                    case "查体":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "vital");
+                        break;
+                    // case "辅检结果":
+                    //     wordStandConvert(standConvertCrfBatchDTO, testwordRes, "pacs");
+                    //     break;
+                    case "化验":
+                        wordStandConvert(standConvertCrfBatchDTO, testwordRes, "lis");
+                        break;
+                    default:
+                        break;
+                }
+                testwordRes.setIsDeal(1);
+                testwordRes.setGmtModified(date);
+            }
+            testwordResService.saveOrUpdateBatch(testwordInfoList);
+
+            testwordInfoList = testwordResService.page(new Page<>(1, 20), queryWrapper).getRecords();
+        }
+    }
+
+    public void wordStandConvert(StandConvertCrfBatchDTO standConvertCrfBatchDTO, TestwordRes testwordRes, String type) {
+        Set<String> typeList = new LinkedHashSet<>();
+        Map<String, StandConvertCrfDTO> convertCrfDTOMap = standConvertCrfBatchDTO.getData().get(type);
+        if (convertCrfDTOMap != null && convertCrfDTOMap.get(testwordRes.getWord()) != null) {
+            List<Map<String,String>> listMap = convertCrfDTOMap.get(testwordRes.getWord()).getStandard_words();
+            int size = 0;
+            for (Map<String,String> map : listMap) {
+                if (size < 3 && StringUtil.isNotBlank(map.get("standard_word"))) {
+                    typeList.add(map.get("standard_word"));
+                }
+                size++;
+            }
+            testwordRes.setConvertWord(StringUtils.join(typeList, "；"));
+        }
+    }
+
+    /**
+     * 筛选对象列表中“uniqueName”字段为空的数据，返回targetProperty字段列表
+     *
+     * @param list
+     * @param <T>
+     * @return
+     */
+    public <T> List<String> getDetail(List<T> list) {
+        if (ListUtil.isEmpty(list)) {
+            return new ArrayList<>();
+        }
+        return list.stream()
+                .filter(r -> StringUtil.isNotBlank((String)CoreUtil.getFieldValue(r, "detailName")))
+                .map(r -> (String)CoreUtil.getFieldValue(r, "detailName"))
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * 症状生成API
+     *
+     * @param symptomFeatureVO
+     */
+    public void getSymptom(SymptomFeatureVO symptomFeatureVO) {
+        if (StringUtil.isBlank(symptomFeatureVO.getPath())) {
+            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "文件目录不能为空");
+        }
+        Map<String, SymptomFeatureList> listMap = new LinkedHashMap<>();
+        try {
+            // 1、获取文件目录
+            File[] files = new File(symptomFeatureVO.getPath()).listFiles();
+            for (File file : files) {
+                // 读取以“.ann”结尾的文件
+                if (!file.getName().endsWith(".ann")) {
+                    continue;
+                }
+                // 2、遍历文件
+                List<Ann> annList = new ArrayList<>();
+                FileReader fileReader = new FileReader(file);
+                BufferedReader br = new BufferedReader(fileReader);
+                String line = "";
+
+                // 3、将文件结构化
+                while ((line = br.readLine()) != null) {
+                    if (StringUtil.isNotBlank(line)) {
+                        String[] arr = line.split(" |\\t");
+                        Ann ann = new Ann();
+                        ann.setId(arr[0]);
+                        ann.setType(arr[1]);
+                        ann.setStart(arr[2]);
+                        ann.setEnd(arr[3]);
+                        ann.setName(arr[4]);
+                        annList.add(ann);
+                    }
+                }
+                Map<String, List<Ann>> typeEntity = EntityUtil.makeEntityListMap(annList, "type");
+                Map<String, List<Ann>> endMap = EntityUtil.makeEntityListMap(annList, "end");
+                Map<String, List<Ann>> startMap = EntityUtil.makeEntityListMap(annList, "start");
+
+                // 4、以最小单元为准，读取相关属性
+                List<Ann> symptomList = typeEntity.get("min_combination_unit");
+                for (Ann ann : symptomList) {
+                    String name = ann.getName();
+                    SymptomFeatureList symptomFeatureList = listMap.get(name);
+                    if (symptomFeatureList == null) {
+                        symptomFeatureList = new SymptomFeatureList();
+                        symptomFeatureList.setMinCombineElement(name);
+                    }
+
+                    List<Ann> currentAnnList = new ArrayList<>();
+                    String value = "";
+                    // 从最小组合单元往上找end
+                    value = ann.getStart();
+                    while (ListUtil.isNotEmpty(currentAnnList = endMap.get(value))) {
+                        Ann annBean = currentAnnList.get(0);
+                        value = annBean.getStart();
+                        setSymptomFeature(annBean, symptomFeatureList);
+                    }
+                    // 从最小组合单元往下找start
+                    value = ann.getEnd();
+                    while (ListUtil.isNotEmpty(currentAnnList = startMap.get(value))) {
+                        Ann annBean = currentAnnList.get(0);
+                        value = annBean.getEnd();
+                        setSymptomFeature(annBean, symptomFeatureList);
+                    }
+                    listMap.put(name, symptomFeatureList);
+                }
+            }
+            // 5、数据库全部删除
+            symptomFeatureService.remove(new QueryWrapper<>());
+            // 6、批量插入
+            List<SymptomFeature> symptomFeatureList = new ArrayList<>();
+            for (String key : listMap.keySet()) {
+                SymptomFeatureList sf = listMap.get(key);
+                SymptomFeature symptomFeature = new SymptomFeature();
+                symptomFeature.setMinCombineElement(key);
+                symptomFeature.setBodyPart(StringUtils.join(sf.getBodyPartList(), "、"));
+                symptomFeature.setPosition(StringUtils.join(sf.getPositionList(), "、"));
+                symptomFeature.setShapePropety(StringUtils.join(sf.getShapePropetyList(), "、"));
+                symptomFeature.setDegree(StringUtils.join(sf.getDegreeList(), "、"));
+                symptomFeature.setColor(StringUtils.join(sf.getColorList(), "、"));
+                symptomFeature.setVariety(StringUtils.join(sf.getVarietyList(), "、"));
+                symptomFeature.setRadiationSituation(StringUtils.join(sf.getRadiationSituationList(), "、"));
+                symptomFeature.setFrequency(StringUtils.join(sf.getFrequencyList(), "、"));
+                symptomFeatureList.add(symptomFeature);
+            }
+            symptomFeatureService.saveBatch(symptomFeatureList);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void addFeature(List<String> list, String name) {
+        if (!list.contains(name)) {
+            list.add(name);
+        }
+    }
+
+    public void setSymptomFeature(Ann annBean, SymptomFeatureList symptomFeatureList) {
+        switch (annBean.getType()) {
+            case "location": // 部位
+                addFeature(symptomFeatureList.getBodyPartList(), annBean.getName());
+                break;
+            case "direction": // 方位
+                addFeature(symptomFeatureList.getPositionList(), annBean.getName());
+                break;
+            case "property": // 形状性质
+                addFeature(symptomFeatureList.getShapePropetyList(), annBean.getName());
+                break;
+            case "extent": // 程度
+                addFeature(symptomFeatureList.getDegreeList(), annBean.getName());
+                break;
+            case "color": // 颜色
+                addFeature(symptomFeatureList.getColorList(), annBean.getName());
+                break;
+            case "change": // 变化
+                addFeature(symptomFeatureList.getVarietyList(), annBean.getName());
+                break;
+            case "rediate": // 放射情况
+                addFeature(symptomFeatureList.getRadiationSituationList(), annBean.getName());
+                break;
+            case "frequency": // 频率
+                addFeature(symptomFeatureList.getFrequencyList(), annBean.getName());
+                break;
+        }
+    }
+}

src/main/java/com/diagbot/facade/TestwordResFacade.java

@@ -0,0 +1,15 @@
+package com.diagbot.facade;
+
+import com.diagbot.service.impl.TestwordResServiceImpl;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhoutg
+ * @time: 2020/7/29 15:03
+ */
+@Component
+public class TestwordResFacade extends TestwordResServiceImpl {
+
+
+}

src/main/java/com/diagbot/mapper/TestwordInfoMapper.java

@@ -0,0 +1,16 @@
+package com.diagbot.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.entity.TestwordInfo;
+
+/**
+ * <p>
+ * 词提取用例 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+public interface TestwordInfoMapper extends BaseMapper<TestwordInfo> {
+
+}

src/main/java/com/diagbot/mapper/TestwordResMapper.java

@@ -0,0 +1,16 @@
+package com.diagbot.mapper;
+
+import com.diagbot.entity.TestwordRes;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ * 词提取结果 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+public interface TestwordResMapper extends BaseMapper<TestwordRes> {
+
+}

src/main/java/com/diagbot/service/TestwordInfoService.java

@@ -0,0 +1,16 @@
+package com.diagbot.service;
+
+import com.diagbot.entity.TestwordInfo;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 词提取用例 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+public interface TestwordInfoService extends IService<TestwordInfo> {
+
+}

src/main/java/com/diagbot/service/TestwordResService.java

@@ -0,0 +1,16 @@
+package com.diagbot.service;
+
+import com.diagbot.entity.TestwordRes;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 词提取结果 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+public interface TestwordResService extends IService<TestwordRes> {
+
+}

src/main/java/com/diagbot/service/impl/TestwordInfoServiceImpl.java

@@ -0,0 +1,20 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.entity.TestwordInfo;
+import com.diagbot.mapper.TestwordInfoMapper;
+import com.diagbot.service.TestwordInfoService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 词提取用例 服务实现类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+@Service
+public class TestwordInfoServiceImpl extends ServiceImpl<TestwordInfoMapper, TestwordInfo> implements TestwordInfoService {
+
+}

src/main/java/com/diagbot/service/impl/TestwordResServiceImpl.java

@@ -0,0 +1,20 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.entity.TestwordRes;
+import com.diagbot.mapper.TestwordResMapper;
+import com.diagbot.service.TestwordResService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 词提取结果 服务实现类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+@Service
+public class TestwordResServiceImpl extends ServiceImpl<TestwordResMapper, TestwordRes> implements TestwordResService {
+
+}

src/main/java/com/diagbot/web/TestwordInfoController.java

@@ -0,0 +1,59 @@
+package com.diagbot.web;
+
+
+import com.diagbot.dto.RespDTO;
+import com.diagbot.facade.TestwordInfoFacade;
+import com.diagbot.vo.SymptomFeatureVO;
+import com.diagbot.vo.TestwordInfoVO;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.Map;
+
+/**
+ * <p>
+ * 词提取用例 前端控制器
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2020-10-29
+ */
+@RestController
+@RequestMapping("/testwordInfo")
+@Api(value = "提词API", tags = { "提词API" })
+public class TestwordInfoController {
+
+    @Autowired
+    TestwordInfoFacade testwordInfoFacade;
+
+    @ApiOperation(value = "提词API[zhoutg]",
+            notes = "提词API")
+    @PostMapping("/getword")
+    public RespDTO<Map<String, String>> getword(@RequestBody TestwordInfoVO testwordInfoVO) {
+        return RespDTO.onSuc(testwordInfoFacade.getWord(testwordInfoVO));
+    }
+
+    @ApiOperation(value = "提词转换API[zhoutg]",
+            notes = "提词转换API")
+    @PostMapping("/wordConvert")
+    public RespDTO<String> wordConvert() {
+        testwordInfoFacade.wordConvert();
+        return RespDTO.onSuc("执行完毕");
+    }
+
+    @ApiOperation(value = "症状生成API[zhoutg]",
+            notes = "症状生成API")
+    @PostMapping("/getSymptom")
+    @Transactional
+    public RespDTO<String> getSymptom(SymptomFeatureVO symptomFeatureVO) {
+        testwordInfoFacade.getSymptom(symptomFeatureVO);
+        return RespDTO.onSuc("执行完毕");
+    }
+
+}

src/main/resources/mapper/TestwordInfoMapper.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.diagbot.mapper.TestwordInfoMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.TestwordInfo">
+        <id column="id" property="id" />
+        <result column="is_deleted" property="isDeleted" />
+        <result column="gmt_create" property="gmtCreate" />
+        <result column="gmt_modified" property="gmtModified" />
+        <result column="creator" property="creator" />
+        <result column="modifier" property="modifier" />
+        <result column="text" property="text" />
+        <result column="type" property="type" />
+        <result column="is_deal" property="isDeal" />
+    </resultMap>
+
+</mapper>

src/main/resources/mapper/TestwordResMapper.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.diagbot.mapper.TestwordResMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.TestwordRes">
+        <id column="id" property="id" />
+        <result column="is_deleted" property="isDeleted" />
+        <result column="gmt_create" property="gmtCreate" />
+        <result column="gmt_modified" property="gmtModified" />
+        <result column="creator" property="creator" />
+        <result column="modifier" property="modifier" />
+        <result column="word" property="word" />
+        <result column="type" property="type" />
+        <result column="convert_word" property="convertWord" />
+        <result column="is_deal" property="isDeal" />
+    </resultMap>
+
+</mapper>