1.更新量表结构接口

2.词性枚举类添加DIGIT("28")
3.添加给症状末尾添加诊断依据标准词方法

bigdata-web/src/main/java/org/diagbot/bigdata/common/ApplicationCacheUtil.java

@@ -2,8 +2,12 @@ package org.diagbot.bigdata.common;
 
 import org.diagbot.bigdata.dao.model.ResultMappingFilter;
 import org.diagbot.bigdata.util.BigDataConstants;
+import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.cfg.Configuration;
 import org.diagbot.nlp.participle.cfg.DefaultConfig;
+import org.diagbot.nlp.participle.word.Lexeme;
+import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpCache;
 import org.diagbot.pub.utils.security.EncrypDES;
 
@@ -24,6 +28,8 @@ public class ApplicationCacheUtil {
     public static Map<String, String> doc_result_mapping_diag_map = null;
     //特征性别 年龄过滤等
     public static Map<String, Map<String, ResultMappingFilter>> doc_result_mapping_filter_map = null;
+    //诊断依据标准词
+    public static Map<String, List<Map<String, String>>> kl_result_mapping_standword_map = null;
 
     public static Map<String, Map<String, String>> getStandard_info_synonym_map() {
         if (standard_info_synonym_map == null) {
@@ -98,4 +104,79 @@ public class ApplicationCacheUtil {
         }
         return doc_result_mapping_filter_map;
     }
+
+    public static Map<String, List<Map<String, String>>> getKl_result_mapping_standword_map() {
+        if (kl_result_mapping_standword_map == null) {
+            kl_result_mapping_standword_map = new HashMap<>();
+            Configuration configuration = new DefaultConfig();
+            ParticipleUtil util = new ParticipleUtil();
+            List<String> fileContents = configuration.readFileContents("kl_result_mapping_standword.dict");
+            List<Map<String, String>> standWordObjValList = null;
+            Map<String, String> standWordObjVal = null;
+            String operationGreater = ">=|≥|>|大于|＞|超过";
+            String operationSmaller = "<=|≤|<|小于|＜|少于";
+            try {
+                for (String fileContent : fileContents) {
+                    LexemePath<Lexeme> lexemes = null;
+                    String op = "";
+                    String[] fileContentSplit = null;
+                    if (fileContent.contains(">=") || fileContent.contains("≥")
+                            || fileContent.contains(">") || fileContent.contains("大于")
+                            || fileContent.contains("＞") || fileContent.contains("超过")){
+                        op = ">";
+                        fileContentSplit = fileContent.split(operationGreater);
+                    } else if (fileContent.contains("<=") || fileContent.contains("≤")
+                            || fileContent.contains("<") || fileContent.contains("小于")
+                            || fileContent.contains("＜") || fileContent.contains("少于")){
+                        op = "<";
+                        fileContentSplit = fileContent.split(operationSmaller);
+                    } else {
+                        continue;
+                    }
+                    for (String fileContentWords:fileContentSplit){
+                        LexemePath<Lexeme> lexemeWord = util.participle(fileContentWords);
+                        if (null == lexemes) {
+                            lexemes = lexemeWord;
+                        } else {
+                            for (Lexeme lexeme:lexemeWord) {
+                                lexemes.add(lexeme);
+                            }
+                        }
+                    }
+                    String standWordObjKey = "";
+                    standWordObjValList = new ArrayList<>();
+                    standWordObjVal = new HashMap<>();
+                    int i = 0;
+                    for (Lexeme lexeme:lexemes) {
+                        i++;
+                        NegativeEnum lexemeNegativeEnum = NegativeEnum.parseOfValue(lexeme.getProperty());
+                        if (lexemeNegativeEnum == NegativeEnum.SYMPTOM || lexemeNegativeEnum == NegativeEnum.CAUSE
+                                || lexemeNegativeEnum == NegativeEnum.VITAL_INDEX) {
+                            if (!kl_result_mapping_standword_map.containsKey(lexeme.getText())) {
+                                kl_result_mapping_standword_map.put(lexeme.getText(), standWordObjValList);
+                            } else {
+                                standWordObjKey = lexeme.getText();
+                            }
+                        } else if (lexemeNegativeEnum == NegativeEnum.DIGITS ) {
+                                standWordObjVal.put("value", lexeme.getText());
+                        } else if (lexemeNegativeEnum == NegativeEnum.UNIT) {
+                                standWordObjVal.put("unit", lexeme.getText());
+                        }
+                        if (lexemes.size() == i) {
+                            standWordObjVal.put("op",op);
+                            standWordObjVal.put("standword",fileContent);
+                            if (kl_result_mapping_standword_map.containsKey(standWordObjKey)) {
+                                kl_result_mapping_standword_map.get(standWordObjKey).add(standWordObjVal);
+                            } else {
+                                standWordObjValList.add(standWordObjVal);
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+        return kl_result_mapping_standword_map;
+    }
 }

bigdata-web/src/main/java/org/diagbot/bigdata/work/ParamsDataProxy.java

@@ -1,16 +1,22 @@
 package org.diagbot.bigdata.work;
 
 import org.algorithm.util.AlgorithmClassify;
+import org.diagbot.bigdata.common.ApplicationCacheUtil;
 import org.diagbot.bigdata.util.BigDataConstants;
 import org.diagbot.common.work.SearchData;
 import org.diagbot.nlp.feature.FeatureAnalyze;
 import org.diagbot.nlp.feature.FeatureType;
+import org.diagbot.nlp.participle.ParticipleUtil;
+import org.diagbot.nlp.participle.word.Lexeme;
+import org.diagbot.nlp.participle.word.LexemePath;
 import org.diagbot.nlp.util.Constants;
+import org.diagbot.nlp.util.NegativeEnum;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.util.StringUtils;
 
 import javax.servlet.http.HttpServletRequest;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -24,6 +30,8 @@ import java.util.Map;
  **/
 public class ParamsDataProxy {
     Logger logger = LoggerFactory.getLogger(ParamsDataProxy.class);
+    ParticipleUtil util = new ParticipleUtil();
+
     public void createSearchData(HttpServletRequest request, SearchData searchData) throws Exception {
         //消除空格
         if (searchData.getSymptom() != null) {
@@ -41,9 +49,15 @@ public class ParamsDataProxy {
         if (StringUtils.isEmpty(searchData.getResourceType())) {
             searchData.setResourceType(BigDataConstants.resource_type_o);
         }
+        //给症状末尾添加诊断依据标准词
+        ApplicationCacheUtil.getKl_result_mapping_standword_map();
+        LexemePath<Lexeme> featureData = util.participle(searchData.getSymptom());
+        if (null != featureData) {
+            addStandWord(featureData, ApplicationCacheUtil.kl_result_mapping_standword_map, searchData);
+        }
         //所有信息参与推送
         searchData.setSymptom(searchData.getSymptom() + searchData.getVital()
-                + searchData.getLis() + searchData.getPacs() + searchData.getPast() + searchData.getOther()+ searchData.getIndications());
+                + searchData.getLis() + searchData.getPacs() + searchData.getPast() + searchData.getOther() + searchData.getIndications());
         searchData.setSymptom(searchData.getSymptom().trim());
         //一次推送多个类别信息
         String[] featureTypes = searchData.getFeatureType().split(",");
@@ -69,6 +83,7 @@ public class ParamsDataProxy {
 
     /**
      * featureType转算法模型类型
+     *
      * @param sysCode
      * @param featureTypes
      * @param searchData
@@ -92,7 +107,7 @@ public class ParamsDataProxy {
                     case DIAG:
                         if (reverse) {
                             classifies[i] = null;
-                        }  else {
+                        } else {
                             classifies[i] = AlgorithmClassify.NEURAL_DIAG;
                         }
                         break;
@@ -139,6 +154,7 @@ public class ParamsDataProxy {
 
     /**
      * 外部系统featureType需要转化为大数据定义的featureType
+     *
      * @param sysCode
      * @param featureType
      * @return
@@ -179,7 +195,7 @@ public class ParamsDataProxy {
      */
     private void paramFeatureInit(SearchData searchData, List<Map<String, Object>> featuresList) throws Exception {
         if (featuresList != null && featuresList.size() > 0) {
-//            BeanUtils.setProperty(searchData, property_list, featuresList);
+            //            BeanUtils.setProperty(searchData, property_list, featuresList);
             Map<String, Object> featureMap = null;
             for (int i = 0; i < featuresList.size(); i++) {
                 featureMap = featuresList.get(i);
@@ -199,4 +215,136 @@ public class ParamsDataProxy {
             }
         }
     }
+
+    /**
+     * 给SearchData中症状末尾添加诊断依据标准词
+     *
+     * @param lexemes
+     * @param standWords
+     * @param sData
+     * @return
+     */
+    public SearchData addStandWord(List<Lexeme> lexemes, Map<String, List<Map<String, String>>> standWords, SearchData sData) {
+        List<Lexeme> feature = new ArrayList<>();
+        //收集分词结果中体征指标或体征指标值（数字）
+        for (Lexeme lexeme : lexemes) {
+            NegativeEnum lexemeNegativeEnum = NegativeEnum.parseOfValue(lexeme.getProperty());
+            if (lexemeNegativeEnum == NegativeEnum.VITAL_INDEX || lexemeNegativeEnum == NegativeEnum.DIGITS
+                    || lexemeNegativeEnum == NegativeEnum.EVENT_TIME || lexemeNegativeEnum == NegativeEnum.UNIT
+                    ) {
+                feature.add(lexeme);
+            }
+        }
+        //根据收集到的分词结果把体征指标和对应体征指标值（数字）拼接
+        List<String> featureType = new ArrayList<>();
+        for (int i = 0; i < feature.size(); i++) {
+            boolean featureTypeState = true;
+            if (i < feature.size() - 2) {
+                if ((NegativeEnum.parseOfValue(feature.get(i).getProperty()) == NegativeEnum.VITAL_INDEX
+                        && NegativeEnum.parseOfValue(feature.get(i + 1).getProperty()) == NegativeEnum.DIGITS
+                        && NegativeEnum.parseOfValue(feature.get(i + 2).getProperty()) == NegativeEnum.EVENT_TIME)
+                        ||
+                        (NegativeEnum.parseOfValue(feature.get(i).getProperty()) == NegativeEnum.VITAL_INDEX
+                                && NegativeEnum.parseOfValue(feature.get(i + 1).getProperty()) == NegativeEnum.DIGITS
+                                && NegativeEnum.parseOfValue(feature.get(i + 2).getProperty()) == NegativeEnum.UNIT)) {
+                    featureType.add(feature.get(i).getText() + "\t" + feature.get(i + 1).getText() + "\t"
+                            + feature.get(i + 2).getText());
+                    featureTypeState = false;
+                }
+            }
+            if (i < feature.size() - 1 && featureTypeState) {
+                if (NegativeEnum.parseOfValue(feature.get(i).getProperty()) == NegativeEnum.VITAL_INDEX
+                        && NegativeEnum.parseOfValue(feature.get(i + 1).getProperty()) == NegativeEnum.DIGITS) {
+                    featureType.add(feature.get(i).getText() + "\t" + feature.get(i + 1).getText());
+                }
+            }
+        }
+        //将标准词中体征指标值（数字）与分词结果中体征指标值（数字）比较
+        for (String f : featureType) {
+            String[] features = f.split("\t");
+            if (standWords.containsKey(features[0])) {
+                List<Map<String, String>> standWordList = standWords.get(features[0]);
+                for (Map<String, String> standWordMap : standWordList) {
+                    if (standWordMap.containsKey("unit") && standWordMap.containsKey("value")) {
+                        if (features.length == 2) {
+                            judgment(sData, features, standWordMap);
+                        } else {
+                            if (standWordMap.get("unit").equals(features[2])) {
+                                judgment(sData, features, standWordMap);
+                            }
+                        }
+                    } else if (standWordMap.containsKey("value")) {
+                        if (features.length == 2) {
+                            judgment(sData, features, standWordMap);
+                        }
+                    }
+                }
+            }
+        }
+        return sData;
+    }
+
+    //将标准词中体征指标值（数字）与分词结果中体征指标值（数字）比较
+    private void judgment(SearchData sData, String[] features, Map<String, String> standWordMap) {
+        if (">".equals(standWordMap.get("op"))) {
+            //单独处理  血压≥140/90mmHg   类似情况
+            if (features[1].contains("/")) {
+                if (standWordMap.get("value").contains("/")) {
+                    String[] feature = features[1].split("/");
+                    Integer featuresSBP = Integer.valueOf(feature[0]); //分词特征收缩压
+                    Integer featuresDBP = Integer.valueOf(feature[1]); //分词特征舒张压
+
+                    String[] values = standWordMap.get("value").split("/");
+                    Integer standWordSBP = Integer.valueOf(values[0]); //标准词收缩压
+                    Integer standWordDBP = Integer.valueOf(values[1]); //标准词舒张压
+                    if (featuresSBP > standWordSBP && featuresDBP > standWordDBP) {
+                        sData.setSymptom(sData.getSymptom() + "," + standWordMap.get("standword"));
+                        System.out.println(sData.getSymptom());
+                    }
+                }
+            } else {
+                String num = getNum(standWordMap.get("value"));
+                if (Double.valueOf(getNum(features[1])) > Double.valueOf(num)) {
+                    sData.setSymptom(sData.getSymptom() + "," + standWordMap.get("standword"));
+                    System.out.println(sData.getSymptom());
+
+                }
+            }
+        } else if ("<".equals(standWordMap.get("op"))) {
+            //单独处理  血压小于90/60mmHg   类似情况
+            if (standWordMap.get("value").contains("/")) {
+                if (features[1].contains("/")) {
+                    String[] feature = features[1].split("/");
+                    Integer featuresSBP = Integer.valueOf(feature[0]); //收缩压
+                    Integer featuresDBP = Integer.valueOf(feature[1]); //舒张压
+
+                    String[] values = standWordMap.get("value").split("/");
+                    Integer standWordSBP = Integer.valueOf(values[0]); //收缩压
+                    Integer standWordDBP = Integer.valueOf(values[1]); //舒张压
+                    if (featuresSBP < standWordSBP && featuresDBP < standWordDBP) {
+                        sData.setSymptom(sData.getSymptom() + "," + standWordMap.get("standword"));
+                        System.out.println(sData.getSymptom());
+                    }
+                }
+            } else {
+                String num = getNum(standWordMap.get("value"));
+                if (Double.valueOf(getNum(features[1])) < Double.valueOf(num)) {
+                    sData.setSymptom(sData.getSymptom() + "," + standWordMap.get("standword"));
+                    System.out.println(sData.getSymptom());
+                }
+            }
+        }
+    }
+
+    private String getNum(String standWord) {
+        StringBuffer sb = new StringBuffer();
+        for (String num : standWord.replaceAll("[^0-9]", ",").split(",")) {
+            if (num.length() > 0) {
+                sb.append(num);
+            }
+        }
+        return sb.toString();
+    }
+
+
 }

bigdata-web/src/main/resources/kl_result_mapping_standword.dict

@@ -0,0 +1,72 @@
+L1EmrYbiw1OUhT2Mgp9IYw==
+ITtp7xJvm7xN85EE9UKFSw==
+wD/+T2Rb77CRvSo1kXtPNEpgEZ36UZf7
+7Mb9gmlxjvh1F9jmC1k7P883fdy234AQ
+uxw8ICp6pO5wpgcXrQMg2VJhtasX0D86
+L1EmrYbiw1OIbvEPe9JVrA==
+L1EmrYbiw1PkvbIQjSH0ig==
+F8CWtrMTFqpULF2mGv8rXkpgEZ36UZf7
+vs5IhqszS0FV5nxcKLHXX+78A3F5ApoOtoX2nv595w8=
+ITtp7xJvm7yIbvEPe9JVrA==
+MsRMye4Ce1Tzd4Q5WYcI38K6Q4zNu6SzmeHG94k7IE0=
+4TVdgXZNhk6n617WIf7gjXqAFzRaz0s/E+oKnTDMgwM=
+Izz3qmtzr5r2IotS+Hrtgdt5hAoCEWE7
+kDiWMe1LBSn7WUAQirnyfkgPjzQSs0k2rBCI2o7bKak=
+8sjigmd8+cDI/ooGhntbPA==
+srat2SPWwxguIyv673ST2QbfxHf7qINy
+ml/2hklo0UHyOdjBHhpw6PD8KRVpDE2pSmARnfpRl/s=
+0otZcLsmIrh2Hs6rzcTSZXR2BAIQaNSQ
+uxw8ICp6pO7cN+yZQPS235v06pW+h+fV
+L1EmrYbiw1M/B+Rc2AlyxA==
+gnVG/ah+09SgRGW2oBYU+OEPDCWsDtGsSmARnfpRl/s=
+ml/2hklo0UHRmEFsc/9x2xajCnoy4DJaiJbgaKVsTrQ=
+IEYbDrCxln+pW/vODY540MSGO/2qkdhdzzd93LbfgBA=
+AotDretpE0ZBFWHcMGrhB79ZnX6q3jyT
+ml/2hklo0UF7OY2n/wXeGT2+sd4EngoW
+Iif1Jo1fyT++bhIKk0opxubM/HlMOKIR
+k1Gm7uC3txeV4R0r6B0UJw==
+uxw8ICp6pO7cN+yZQPS239cJHQx8ZPvQ
+F8CWtrMTFqoniUaZHKRtDg==
+O42GEYS2XrdrGTzkULBH0kpgEZ36UZf7
+lkGXVn+qv6wGpUvQ4LCbUQbfxHf7qINy
+Z8+G5B4yQAJEwaP0L1YpIsPLHHt4XU0w
+p2ksykmrwo4sihl+rIlDVaVct0+Wq2CHEEF4xA7BbNegwlRNlXVsGDiKp8v4EWLupiYV+OrJ7h95YV9F3XyyBQ==
+4TVdgXZNhk5uKjwx+NAMWfTPF+uOpY+N
+F8CWtrMTFqowgxhDjRXyhEpgEZ36UZf7
+8dihNLZO9dsX36WzpVuRF37u779IPQ1ApHp904IlTO0=
+qFhztcYdBhFSDqcM0GqgiEpgEZ36UZf7
+Dtl+1pXSqsCf7K9ZHfGUKeT5pyumoJAc
+ml/2hklo0UHyOdjBHhpw6LIcBy6P5pyfSmARnfpRl/s=
+M70fhXofuTuHyKDY6fnNSg==
+agwII1gQdty9lYvhKCiqzS8U3XrqgX2Qav3bY6gAyDY=
+kQHtQ28+jmRAgr/8kpwGtkoFpO2Z+GK8mk4WDpuB0fM=
+L1EmrYbiw1MHlWGXOa5WbQ==
+JC9KNSWPlz/yDK/cT4Wye5J2baIy6NOV
+ZXupFoR9xZZjPoDtlfNC/A==
+vs5IhqszS0FV5nxcKLHXX7RwSUIUaOzHYqTxfQMiC+k=
+LIhCJXufKxbf6yFB4KnNr7rtJS+DwsR+
+vs5IhqszS0FV5nxcKLHXX7RwSUIUaOzHHbSHS03vfmM=
+XLKpe1H4VQhm8TLMxgEyXHG+vSuxnv1tO6MyYWiOJ+8=
+SxCOqpR2m2vgqikXUwdVYSLuXWTUWavGdSu4/NSFMh2JDVVDa5aQ2qaDIhnMf3RgNSgeLpxHM1E=
+wYpoUOLxkWFyh8xi1Rb8FaKZXwCRnuzt
+xKjH098+V6WUhT2Mgp9IYw==
+wD/+T2Rb77DCStLw9D5GqEpgEZ36UZf7
+eOtp99ION5Ds8QGp8Y0fbaA/XJb5OMRF
+TTBoaK2XBA4Ul03O+JczYJkRlKkZ9goc
+Gl9t95Qgz7iDmNITYSpk9CnCJ2qqEZhF21nfxGCpJI4=
+deJ9ShdG0Iy3IgDj49Nd+wNeAFNXO6znEuIPRVt0zxrIFF7BEQ9/q5jT4dqI9dL0uKZSIUBrfqA=
+5b10ZecEq03DkIo5s7WKJO+9h847MVcISRS2rAck6VmAbjjMVsD+tagfqsNDuH7D0Zi/2VsQQhM=
+jkwAIBuL8J2rfWt+2fRjEHK76WBBMdTh
+wD/+T2Rb77DRxndKkqpYem2vzYM7pAHX
+JFoPNMqvscDYfrYzhvi2TUpgEZ36UZf7
+o586QSXa3yeSW7t/AXaZIPTPF+uOpY+N
+QuVFY0AsqDePuV7DZypuDJvIFLIFEYbK9AhSgsk0aTOyK9+CPwy73SvTg01va5zFEzbsQLwk3co+DpVh+1RB20pgEZ36UZf7
+8q2ztLDj5WrCOGEPa6tCFpTz+I5xZDsT
+HdMzbFa8esje00No8KDgnw==
+xbaeH6dIBS3RxndKkqpYel0Yre9PRlQPBiNf+1YVhVY=
+JC9KNSWPlz932m7E2QUuLb9PY5/aDDrQ
+KXjWK7CEAInDL9KKIPcR9w==
+Dtl+1pXSqsCdXBQ/c9gkD5Tz+I5xZDsT
+Z8+G5B4yQAJkIniXV51XYQbfxHf7qINy
+OiF4bqXkMEEAhZ46GKERaQ==
+6AdBr9ESXwxuAA4RzKQl7T8g5XqLhLp48PwpFWkMTalKYBGd+lGX+w==

bigdata-web/src/test/java/org/diagbot/AddStandWordTest.java

@@ -0,0 +1,58 @@
+package org.diagbot;
+
+import org.diagbot.bigdata.common.ApplicationCacheUtil;
+import org.diagbot.bigdata.work.ParamsDataProxy;
+import org.diagbot.common.work.SearchData;
+import org.diagbot.nlp.participle.ParticipleUtil;
+import org.diagbot.nlp.participle.cfg.Configuration;
+import org.diagbot.nlp.participle.cfg.DefaultConfig;
+import org.diagbot.nlp.participle.word.Lexeme;
+import org.diagbot.nlp.participle.word.LexemePath;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * @Description:
+ * @Author: HUJING
+ * @Date: 2019/7/2 10:31
+ */
+public class AddStandWordTest {
+    public static void main(String[] args) throws Exception {
+//        Map<String, List<Map<String, String>>> kl_result_mapping_standword_map = ApplicationCacheUtil.getKl_result_mapping_standword_map();
+//        Set<Map.Entry<String, List<Map<String, String>>>> entries = kl_result_mapping_standword_map.entrySet();
+//        for (Map.Entry<String, List<Map<String, String>>> entry:entries) {
+//            System.out.println(entry.getKey() + "\t"+ entry.getValue());
+//        }
+//        Configuration configuration = new DefaultConfig();
+        ParticipleUtil util = new ParticipleUtil();
+//        List<String> fileContents = configuration.readFileContents("kl_result_mapping_standword.dict");
+//        for (String fileContent:fileContents) {
+//            if (fileContent.contains(">=") || fileContent.contains("≥")
+//                    || fileContent.contains(">") || fileContent.contains("大于")
+//                    || fileContent.contains("＞") || fileContent.contains("超过")
+//                    || fileContent.contains("<=") || fileContent.contains("≤")
+//                    || fileContent.contains("<") || fileContent.contains("小于")
+//                    || fileContent.contains("＜") || fileContent.contains("少于")){
+//                String[] fileContentSplit = fileContent.split("<=|≤|<|小于|＜|少于|>=|≥|>|大于|＞|超过");
+//                for (String s:fileContentSplit) {
+//                    LexemePath<Lexeme> lexemes = util.participle(s);
+//                    for (Lexeme lexeme:lexemes) {
+//                        if (lexeme.getProperty().equals("2")) {
+//                            System.out.println(lexeme.getText() + "\t" + lexeme.getProperty());
+//                        }
+//                    }
+//                }
+//            }
+//        }
+        ApplicationCacheUtil.getKl_result_mapping_standword_map();
+        SearchData searchData = new SearchData();
+        searchData.setSymptom("收缩压大于170mmHg,R 29次/分钟，额破格配好");
+        LexemePath<Lexeme> data = util.participle(searchData.getSymptom());
+        ParamsDataProxy paramsDataProxy = new ParamsDataProxy();
+
+        paramsDataProxy.addStandWord(data,ApplicationCacheUtil.kl_result_mapping_standword_map,searchData);
+    }
+
+}

bigdata-web/src/test/java/org/diagbot/CacheFileManagerTest.java

@@ -48,21 +48,26 @@ public class CacheFileManagerTest {
 //            }
 //            fw.close();
             //疾病科室
-            String sql = "SELECT k1.lib_name diag_name, k2.lib_name dept_name FROM kl_concept_common kcc, kl_concept k1, kl_concept k2 " +
-                    "where kcc.concept_id = k1.id and kcc.dept_id = k2.id " +
-                    "and k1.lib_type = 18 and kcc.dept_id  is not null";
+//            String sql = "SELECT k1.lib_name diag_name, k2.lib_name dept_name FROM kl_concept_common kcc, kl_concept k1, kl_concept k2 " +
+//                    "where kcc.concept_id = k1.id and kcc.dept_id = k2.id " +
+//                    "and k1.lib_type = 18 and kcc.dept_id  is not null";
+            String sql = "SELECT lib_name FROM kl_concept WHERE is_deleted = 'N' AND lib_type = 70 AND lib_name regexp '[0-9]'";
             st = conn.createStatement();
             rs = st.executeQuery(sql);
-            List<Map.Entry<String, String>> libraryList = rsToMap(rs, true);
+//            List<Map.Entry<String, String>> libraryList = rsToMap(rs, true);
 
-            FileWriter fw = new FileWriter(path + "src/main/resources/doc_result_mapping_diag.dict");
-            for (Map.Entry<String, String> entry : libraryList) {
-                fw.write(encrypDES.encrytor(entry.getKey() + "|" + entry.getValue()));
+            FileWriter fw = new FileWriter(path + "src/main/resources/kl_result_mapping_standword.dict");
+//            for (Map.Entry<String, String> entry : libraryList) {
+//                fw.write(encrypDES.encrytor(entry.getKey() + "|" + entry.getValue()));
+//                fw.write("\n");
+//            }
+            while (rs.next()){
+                fw.write(encrypDES.encrytor(rs.getString(1)));
                 fw.write("\n");
             }
             fw.close();
             //性别年龄
-            sql = "SELECT k1.lib_name, k1.lib_type, kcc.sex_type, kcc.min_age, kcc.max_age " +
+            /*sql = "SELECT k1.lib_name, k1.lib_type, kcc.sex_type, kcc.min_age, kcc.max_age " +
                     "FROM kl_concept_common kcc, kl_concept k1 " +
                     "where kcc.concept_id = k1.id " +
                     "and k1.lib_type in (1, 18) and kcc.dept_id  is not null;";
@@ -83,7 +88,7 @@ public class CacheFileManagerTest {
                 fw.write(encrypDES.encrytor(r1 + "|" + r2 + "|" + r3 + "|" + r4 + "|" + r5));
                 fw.write("\n");
             }
-            fw.close();
+            fw.close();*/
 
         } catch (IOException ioe) {
             ioe.printStackTrace();

graph/src/main/java/org/diagbot/graph/jdbc/Neo4jAPI.java

@@ -2333,7 +2333,7 @@ public class Neo4jAPI {
                 text = rec.get("n2.name").toString().replace("\"", "");
                 mutex = rec.get("r2mutex").toString().replace("\"", "");
                 required = rec.get("n2required").toString().replace("\"", "");
-                index = rec.get("n3name").toString().replaceAll("(\"|_)", "").split("-")[0];
+                index = rec.get("n3name").toString().replaceAll("(\"|_)", "");
                 coefficient = rec.get("n3coefficient").toString().replace("\"", "");//系数
                 constant = rec.get("n3constant").toString().replace("\"", "");//常数
                 controlType = rec.get("n3controlType").toString().replace("\"", "");
@@ -2365,6 +2365,11 @@ public class Neo4jAPI {
                 if (group.contains("-")) {
                     group = group.split("-")[0];
                 }
+
+                if (index.contains("-")) {
+                    index = index.split("-")[0];
+                }
+
                 if (group.contains("计算方法")) {
                     String[] range = mutex.split("~|-");
                     String min = range[0];

nlp/src/main/java/org/diagbot/nlp/util/NegativeEnum.java

@@ -9,7 +9,7 @@ public enum NegativeEnum {
     LIS_TYPE("12"), LIS_NAME("13"), LIS_RESULT("14"), WAY("15"),
     PACS_NAME("16"), PACS_RESULT("17"),
     DISEASE("18"), JOIN("19"), POSITION("20"), FAMILY("21"), FOOD("23"), PAST("24"), OPERATION("25"),
-    SYMPTOM_PERFORMANCE("26"), NUMBER_QUANTIFIER("27"),
+    SYMPTOM_PERFORMANCE("26"), NUMBER_QUANTIFIER("27"), DIGITS("28"),
     OTHER("44"),
     VITAL_INDEX("33"), VITAL_INDEX_VALUE("34"), VITAL_RESULT("35"),
     ADDRESS("36"), PERSON("38"), PERSON_FEATURE_DESC("39"),
@@ -26,7 +26,9 @@ public enum NegativeEnum {
     }
 
     public static org.diagbot.nlp.util.NegativeEnum parseOfValue(String value) {
-        if (value == null) return org.diagbot.nlp.util.NegativeEnum.OTHER;
+        if (value == null) {
+            return org.diagbot.nlp.util.NegativeEnum.OTHER;
+        }
         org.diagbot.nlp.util.NegativeEnum negativeEnum = org.diagbot.nlp.util.NegativeEnum.OTHER;
         switch (value) {
             case "0":
@@ -110,9 +112,12 @@ public enum NegativeEnum {
             case "27":
                 negativeEnum = NegativeEnum.NUMBER_QUANTIFIER;
                 break;
-//            case "44":
-//                negativeEnum = NegativeEnum.SCALE;
-//                break;
+            case "28":
+                negativeEnum = NegativeEnum.DIGITS;
+                break;
+            //            case "44":
+            //                negativeEnum = NegativeEnum.SCALE;
+            //                break;
             case "33":
                 negativeEnum = org.diagbot.nlp.util.NegativeEnum.VITAL_INDEX;
                 break;