Merge remote-tracking branch 'origin/push-dev' into push-dev-similar

algorithm/src/main/resources/algorithm.properties

@@ -2,7 +2,7 @@
 
 #basicPath=E:/project/push/algorithm/src/main/models/model_version_replacement/model
 basicPath=/opt/models/dev/models/model_version_replacement/model
-#basicPath=E:/re_models/model_version_replacement/model
+#basicPath=F:/models/model_version_replacement/model
 
 ############################### current model version ################################
 diagnosisPredict.version=outpatient_556_IOE_1

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

@@ -25,6 +25,7 @@ import java.util.*;
  **/
 public class AlgorithmCore {
     Logger logger = LoggerFactory.getLogger(AlgorithmCore.class);
+
     public ResponseData algorithm(HttpServletRequest request, SearchData searchData, ResponseData responseData) throws Exception {
         //录入文本处理，包括提取特征、推送类型转换等
         BigDataParamsProxy paramsDataProxy = new BigDataParamsProxy();
@@ -50,7 +51,8 @@ public class AlgorithmCore {
             AlgorithmExecutor executor = AlgorithmFactory.getInstance(classifies[i]);
             Map<String, Float> featuresMap = null;
             if (executor != null) {
-                featuresMap = executor.execute(bigDataSearchData.getInputs());;
+                featuresMap = executor.execute(bigDataSearchData.getInputs());
+                ;
             }
             List<Map.Entry<String, Float>> featuresOrderList = null;
             if (featuresMap == null) {

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

@@ -22,6 +22,7 @@ public class BigDataParamsProxy {
         ParamsDataProxy paramsDataProxy = new ParamsDataProxy();
         paramsDataProxy.createSearchData(searchData);
     }
+
     /**
      * featureType转算法模型类型
      *

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

@@ -1,8 +1,11 @@
 package org.diagbot.bigdata.work;
 
+import com.alibaba.fastjson.JSON;
 import org.apache.commons.lang3.StringUtils;
 import org.diagbot.common.push.bean.FeatureRate;
+import org.diagbot.common.push.bean.ResponseData;
 import org.diagbot.common.push.bean.ResultMappingFilter;
+import org.diagbot.common.push.bean.SearchData;
 import org.diagbot.common.push.cache.ApplicationCacheUtil;
 import org.diagbot.nlp.feature.FeatureType;
 import org.diagbot.nlp.util.Constants;
@@ -139,4 +142,67 @@ public class ResultDataProxy {
         }
         return result;
     }
+
+    /**
+     * 化验辅检体征，年龄性别过滤
+     *
+     * @param responseData
+     * @param searchData
+     * @return
+     */
+    public ResponseData resultSexAgeFilter(HttpServletRequest request, ResponseData responseData, SearchData searchData) {
+        if (responseData.getLabs().size() > 0) {//化验
+            responseData.setLabs(sexFilter(request, responseData.getLabs(), searchData, Constants.feature_type_lis));
+        }
+        if (responseData.getPacs().size() > 0) {//辅检
+            responseData.setPacs(sexFilter(request, responseData.getPacs(), searchData, Constants.feature_type_pacs));
+        }
+        if (responseData.getVitals().size() > 0) {//查体
+            responseData.setVitals(sexFilter(request, responseData.getVitals(), searchData, Constants.feature_type_vital));
+        }
+        return responseData;
+    }
+
+    public List<FeatureRate> sexFilter(HttpServletRequest request, List<FeatureRate> featureList, SearchData searchData, String featureType) {
+        List<FeatureRate> featureRates = new ArrayList<>(10);//用来存放传入的数据结果
+        List<FeatureRate> featureRateList = new ArrayList<>(10);//用来存放返回结果
+        Map<String, Map<String, ResultMappingFilter>> resultMappingFilterMap = ApplicationCacheUtil.getDoc_result_mapping_lpvSex_filter_map();
+        boolean isFirst = false;
+        for (int i = 0; i < featureList.size(); i++) {
+            FeatureRate entity = JSON.parseObject(JSON.toJSONString(featureList.get(i)), FeatureRate.class);
+            featureRates.add(entity);
+        }
+        for (FeatureRate featureRate : featureRates) {
+            isFirst = false;
+            //性别年龄过滤
+            Map<String, ResultMappingFilter> filterMap = resultMappingFilterMap.get(featureType);
+            if (filterMap != null) {
+                ResultMappingFilter filter = filterMap.get(featureRate.getFeatureName());
+                if (filter != null) {
+                    if (filter.getSex() != null && !StringUtils.isEmpty(searchData.getSex())
+                            && !filter.getSex().equals(searchData.getSex())) {      //性别过滤
+                        isFirst = true;
+                    } else {
+                        isFirst = false;
+                    }
+                    //年龄过滤
+                    if (filter.getAgeStart() > -1 && searchData.getAge() != 0 && searchData.getAge() < filter.getAgeEnd()) {
+                        isFirst = true;
+                    } else {
+                        isFirst = false;
+                    }
+                    if (filter.getAgeEnd() > -1 && searchData.getAge() != 0 && searchData.getAge() > filter.getAgeStart()) {
+                        isFirst = true;
+                    } else {
+                        isFirst = false;
+                    }
+                }
+                if (isFirst) {
+                    featureRateList.add(featureRate);
+                }
+            }
+        }
+        return featureRateList;
+    }
+
 }

common-push/pom.xml

@@ -28,12 +28,6 @@
             <artifactId>nlp</artifactId>
             <version>1.0.0</version>
         </dependency>
-
-        <dependency>
-            <groupId>org.diagbot</groupId>
-            <artifactId>common-service</artifactId>
-            <version>1.0.0</version>
-        </dependency>
     </dependencies>
 
     <build>

common-push/src/main/java/org/diagbot/common/push/bean/SearchData.java

@@ -1,5 +1,7 @@
 package org.diagbot.common.push.bean;
 
+import org.diagbot.nlp.rule.module.PreResult;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;

common-push/src/main/java/org/diagbot/common/push/cache/ApplicationCacheUtil.java

@@ -22,6 +22,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, Map<String, ResultMappingFilter>> doc_result_mapping_lpvSex_filter_map = null;
     // 规则
     public static Map<String, List<Rule>> kl_rule_filter_map = null;
     //危险值提醒
@@ -49,6 +51,13 @@ public class ApplicationCacheUtil {
         return doc_result_mapping_diag_map;
     }
 
+    public static Map<String, Map<String, ResultMappingFilter>> getDoc_result_mapping_lpvSex_filter_map() {
+        if (doc_result_mapping_lpvSex_filter_map == null) {
+            createDoc_result_mapping_lpvSex_filter_map();
+        }
+        return doc_result_mapping_lpvSex_filter_map;
+    }
+
     public static Map<String, Map<String, ResultMappingFilter>> getDoc_result_mapping_filter_map() {
         if (doc_result_mapping_filter_map == null) {
             createDoc_result_mapping_filter_map();
@@ -91,6 +100,46 @@ public class ApplicationCacheUtil {
         return doc_result_mapping_filter_map;
     }
 
+    /**
+     * 化验辅检体征年龄性别过滤
+     *
+     * @return
+     */
+    public static Map<String, Map<String, ResultMappingFilter>> createDoc_result_mapping_lpvSex_filter_map() {
+        Configuration configuration = new DefaultConfig();
+        List<String> fileContents = configuration.readFileContents("bigdata_lpv_sex_age_filter.dict");
+        String[] line_string;
+        List<ResultMappingFilter> resultMappingFilters = new ArrayList<>();
+        try {
+            for (int i = 0; i < fileContents.size(); i++) {
+                line_string = org.apache.commons.lang3.StringUtils.split(fileContents.get(i), "\\|");
+                if (line_string.length == 5) {
+                    ResultMappingFilter resultMappingFilter = new ResultMappingFilter();
+                    resultMappingFilter.setFeatureName(line_string[0]);
+                    resultMappingFilter.setFeatureType(line_string[1]);
+                    resultMappingFilter.setSex(line_string[2]);
+                    resultMappingFilter.setAgeStart(Integer.parseInt(line_string[3]));
+                    resultMappingFilter.setAgeEnd(Integer.parseInt(line_string[4]));
+                    resultMappingFilters.add(resultMappingFilter);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+        doc_result_mapping_lpvSex_filter_map = new HashMap<>();
+        Map<String, ResultMappingFilter> filterMap = null;
+        for (ResultMappingFilter resultMappingFilter : resultMappingFilters) {
+            filterMap = doc_result_mapping_lpvSex_filter_map.get(resultMappingFilter.getFeatureType());
+            if (filterMap == null) {
+                filterMap = new HashMap<>();
+            }
+            filterMap.put(resultMappingFilter.getFeatureName(), resultMappingFilter);
+            doc_result_mapping_lpvSex_filter_map.put(resultMappingFilter.getFeatureType(), filterMap);
+        }
+        return doc_result_mapping_lpvSex_filter_map;
+    }
+
 
     public static Map<String, List<Rule>> getKl_rule_filter_map() {
         if (kl_rule_filter_map == null) {

common-push/src/main/java/org/diagbot/common/push/cache/CacheFileManager.java

@@ -411,6 +411,37 @@ public class CacheFileManager {
             }
             fw.close();
 
+            //化验辅检体征性别年龄
+            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,12,16,33,35)";
+            st = conn.createStatement();
+            rs = st.executeQuery(sql);
+            fw = new FileWriter(path + "bigdata_lpv_sex_age_filter.dict");//化验辅检体征相关文件
+            while (rs.next()) {
+                r1 = rs.getString(1);
+                r2 = rs.getString(2);
+                r3 = rs.getString(3);
+                r4 = rs.getString(4);
+                r5 = rs.getString(5);
+                if ("18".equals(r2)) {//诊断
+                    r2 = "2";
+                }
+                if ("12".equals(r2)) {//化验
+                    r2 = "4";
+                }
+                if ("16".equals(r2)) {//辅检
+                    r2 = "5";
+                }
+                if ("33".equals(r2) | "35".equals(r2)) {//体征
+                    r2 = "3";
+                }
+                fw.write(encrypDES.encrytor(r1 + "|" + r2 + "|" + r3 + "|" + r4 + "|" + r5));
+                fw.write("\n");
+            }
+            fw.close();
+
         } catch (IOException ioe) {
             ioe.printStackTrace();
         } catch (SQLException sqle) {

common-push/src/main/java/org/diagbot/common/push/filter/ClassifyDiag.java

@@ -111,9 +111,9 @@ public class ClassifyDiag {
                 for (String queDis:queSet) {
                     if(queDiagList.indexOf(queDis)>=0){ //可以找到，就取出来，用原来的
                         FeatureRate feature = this.getFeature(updateFeatures, queDis);
-                        if(feature.getDesc().contains("拟诊")){
-                            feature.setDesc(feature.getDesc().replace("拟诊","确诊"));
-                        }
+//                        if(feature.getDesc().contains("拟诊")){
+                            feature.setDesc(feature.getDesc());
+//                        }
                         feature.setExtraProperty(diagDepartCache.get(queDis));
                         finalDiagList.add(feature);
                     }else {

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentLis.java

@@ -1,93 +0,0 @@
-package org.diagbot.common.push.filter.pretreat;
-
-import org.apache.commons.lang3.StringUtils;
-import org.diagbot.common.push.bean.PreResult;
-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.NegativeEnum;
-import org.diagbot.nlp.util.NlpUtil;
-
-import java.util.List;
-
-public class PretreatmentLis extends Pretreatment {
-    private String join_symbols = ";:；：";
-    protected NegativeEnum[] lisResult = new NegativeEnum[]{NegativeEnum.LIS_RESULT};
-
-    public List<PreResult> analyze(String content) throws java.io.IOException {
-        List<PreResult> preResults = super.analyzeDefault(content);
-        LexemePath<Lexeme> lexemes = ParticipleUtil.participle(content);
-        for (int i = 0; i < lexemes.size(); i++) {
-            Lexeme l = lexemes.get(i);
-            if (NlpUtil.isFeature(l.getProperty(), lisResult)) {
-                cursor = i;
-                PreResult result = new PreResult();
-                result = findPreResultPub(lexemes, result);
-                if (result != null) {
-                    result.setOtherValue(l.getText());
-                    preResults.add(result);
-                }
-            }
-        }
-        return preResults;
-    }
-
-    public PreResult createPreResult(LexemePath<Lexeme> lexemes, Lexeme lexeme, int index) {
-        PreResult result = new PreResult();
-        double value = findNumberValue(lexemes, lexeme, index);
-        if (value == -1) return null;
-        result.setValue(String.valueOf(value));
-        result.setUnits(lexeme.getText());
-        return findPreResultPub(lexemes, result);
-    }
-
-    public PreResult findPreResultPub(LexemePath<Lexeme> lexemes, PreResult result) {
-        //继续往前找化验明细项
-        if (cursor > 0) cursor--;
-        Lexeme leftLexeme = lexemes.get(cursor);
-        if (join_symbols.contains(leftLexeme.getText())) {
-            if (cursor > 0) {
-                cursor--;
-                leftLexeme = lexemes.get(cursor);
-            } else {
-                return null;
-            }
-        }
-        if (NlpUtil.isFeature(leftLexeme.getProperty(), new NegativeEnum[]{NegativeEnum.LIS_NAME})) {
-            result.setDetailName(NlpUtil.concept(leftLexeme, NegativeEnum.LIS_NAME));
-        } else if (NlpUtil.isFeature(leftLexeme.getProperty(), new NegativeEnum[]{NegativeEnum.PUB_NAME})) {
-            result.setUniqueName(NlpUtil.concept(leftLexeme, NegativeEnum.PUB_NAME));
-        } else {
-            return null;
-        }
-
-        //查找化验套餐
-        int position = cursor - 1;
-        while (position > -1) {
-            leftLexeme = lexemes.get(position);
-            if (NlpUtil.isFeature(leftLexeme.getProperty(), new NegativeEnum[]{NegativeEnum.LIS_TYPE})) {
-                result.setName(NlpUtil.concept(leftLexeme, NegativeEnum.LIS_TYPE));
-                break;
-            }
-            position--;
-        }
-
-        if (StringUtils.isEmpty(result.getUniqueName())){
-            if (StringUtils.isNotEmpty(result.getDetailName()) && StringUtils.isNotEmpty(result.getName())){
-                result.setUniqueName(result.getName() + "--" + result.getDetailName());
-            } else if (StringUtils.isNotEmpty(result.getDetailName())){
-                result.setUniqueName(result.getDetailName());
-            } else if (StringUtils.isNotEmpty(result.getName())){
-                result.setUniqueName(result.getName());
-            } else {
-                return null;
-            }
-        }
-
-        return result;
-    }
-
-    public String findBodyValue(LexemePath<Lexeme> lexemes, Lexeme lexeme, int index) {
-        return null;
-    }
-}

common-push/src/main/java/org/diagbot/common/push/filter/rule/PretreatmentRule.java

@@ -1,13 +1,11 @@
 package org.diagbot.common.push.filter.rule;
 
 
-import org.diagbot.common.push.bean.PreResult;
-import org.diagbot.common.push.bean.ResponseData;
 import org.diagbot.common.push.bean.Rule;
 import org.diagbot.common.push.bean.SearchData;
 import org.diagbot.common.push.cache.ApplicationCacheUtil;
-import org.diagbot.common.push.filter.pretreat.*;
-import org.diagbot.pub.Constants;
+import org.diagbot.nlp.rule.module.PreResult;
+import org.diagbot.nlp.rule.pretreat.*;
 import org.springframework.util.StringUtils;
 
 import java.io.IOException;
@@ -63,13 +61,6 @@ public class PretreatmentRule {
         return add2PreResultList(preResultList, content, ruleType, searchData);
     }
 
-    public static void main(String[] args) throws IOException {
-        PretreatmentRule pretreatmentRule = new PretreatmentRule();
-        SearchData searchData = new SearchData();
-        searchData.setSymptom("钠(Na)110mmol/L");
-        pretreatmentRule.rule(searchData);
-    }
-
     private String add2PreResultList(List<PreResult> preResultList, String content, String ruleType, SearchData searchData) throws java.io.IOException {
         Map<String, List<Rule>> kl_rule_filter_map = ApplicationCacheUtil.getKl_rule_filter_map();
         //符合条件的规则

common-push/src/main/java/org/diagbot/common/push/work/ParamsDataProxy.java

@@ -1,10 +1,15 @@
 package org.diagbot.common.push.work;
 
+import com.alibaba.fastjson.JSON;
 import org.algorithm.core.cnn.AlgorithmCNNExecutor;
 import org.algorithm.core.cnn.AlgorithmCNNExecutorPacs;
 import org.algorithm.factory.RelationExtractionFactory;
 import org.apache.commons.lang3.StringUtils;
+import org.diagbot.common.push.bean.FeatureRate;
+import org.diagbot.common.push.bean.ResponseData;
+import org.diagbot.common.push.bean.ResultMappingFilter;
 import org.diagbot.common.push.bean.SearchData;
+import org.diagbot.common.push.cache.ApplicationCacheUtil;
 import org.diagbot.common.push.util.PushConstants;
 import org.diagbot.nlp.feature.FeatureAnalyze;
 import org.diagbot.nlp.feature.FeatureType;
@@ -13,6 +18,7 @@ import org.diagbot.nlp.util.NegativeEnum;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import javax.servlet.http.HttpServletRequest;
 import java.util.*;
 
 /**

common-push/src/main/java/org/diagbot/common/push/work/RelationExtractionUtil.java

@@ -61,15 +61,18 @@ public class RelationExtractionUtil {
             }
             if (isExist(sb.toString())) {
                 Map<String, String> map = new HashMap<>();
-                map.put("featureType", "5");
+                map.put("featureType", Constants.feature_type_pacs);
                 map.put("featureName", sb.toString());
-                map.put("property", "17");
+                map.put("property", Constants.word_property_PACS_Result);
                 map.put("concept", sb.toString());
                 //全是有
                 map.put("negative", Constants.default_negative);
                 if (searchData.getInputs().get(map.get("featureName")) == null) {
                     searchData.getInputs().put(map.get("featureName"), map);
                 }
+                if (searchData.getGraphInputs().get(map.get("featureName")) == null) {
+                    searchData.getGraphInputs().put(map.get("featureName"), map);
+                }
             }
         }
     }

graph-web/src/main/java/org/diagbot/graphWeb/work/GraphCalculate.java

@@ -5,7 +5,6 @@ import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.commons.lang3.StringUtils;
 import org.diagbot.common.push.bean.FeatureRate;
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.common.push.bean.ResponseData;
 import org.diagbot.common.push.bean.SearchData;
 import org.diagbot.common.push.bean.neo4j.Filnlly;
@@ -19,7 +18,7 @@ import org.diagbot.graph.jdbc.Neo4jAPI;
 import javax.servlet.http.HttpServletRequest;
 import java.util.*;
 
-import org.diagbot.graphWeb.util.MapValueComparator;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -60,12 +59,7 @@ public class GraphCalculate {
                 }
             }
         }
-        Map<String, Map<String, String>> inputsMap = searchData.getInputs();
-        if(inputsMap != null && inputsMap.size()>0){
-            if(inputsMap.keySet()!=null && inputsMap.keySet().size()>0){
-                ss.addAll(inputsMap.keySet()) ;
-            }
-        }
+
         logger.info("从分词系统接收到的词 :" + ss);
         System.out.println("Participle takes: " + (System.currentTimeMillis()-starttime)/1000d + 's');
         List<String> featureTypeList = Arrays.asList(searchData.getFeatureTypes());

graph/src/main/resources/bolt.properties

@@ -7,7 +7,7 @@ pass_235 = diagbot@20180822
 #\u7EBF\u4E0A\u4F7F\u7528
 bolt.uri=bolt://192.168.2.233
 bolt.user=neo4j
-bolt.passwd=root
+bolt.passwd=123456
 
 
 #\u6D4B\u8BD5\u4F7F\u7528

graphdb/src/main/java/org/diagbot/pub/Ciku.java

@@ -2,7 +2,7 @@ package org.diagbot.pub;
 
 public enum Ciku {
     SYMPTOM("1","1,70"),VITAL_RESULT("2","35,70"),BIGlIS("3","12"),SUBLIS("subLis","13")
-    ,RESULTLIS("resultLis","14,70"),PACS("4","16"),RESULTPACS("resultPacs","17,70"),DISEASE("5","18")
+    ,RESULTLIS("resultLis","14"),PACS("4","16"),RESULTPACS("resultPacs","17"),DISEASE("5","18")
     ,HISTORY("6","18,70"),CAUSE("7","5,70"),PROGNOSIS("8","70"),OTHER("9","70");
     private String name;
     private String label;

graphdb/src/main/java/org/diagbot/repository/BiRepository.java

@@ -0,0 +1,184 @@
+package org.diagbot.repository;
+
+import org.diagbot.entity.node.Disease;
+import org.springframework.data.neo4j.annotation.Query;
+import org.springframework.data.neo4j.repository.Neo4jRepository;
+
+import java.util.List;
+import java.util.Map;
+
+public interface BiRepository extends Neo4jRepository<Disease, Long> {
+    List<Disease> findByNameContaining(String token);
+    //查找图谱中诊断依据数量
+    @Query("match(d:Disease)<-[r:确诊|:拟诊]-(c:Condition) return count(distinct d.name) as discount")
+    Long diagnoseCount();
+    //查找图谱中的儿科疾病数量
+    @Query("MATCH (n:Disease)<-[r:确诊|:拟诊]-(c:Condition) where n.maxAge < 200 and n.minAge =0 RETURN count(distinct n.name) as child")
+    Long childCount();
+    //图谱中有内容的量表数量
+    @Query("MATCH (n:Scale) RETURN count(distinct n.name) as scaleCount")
+    Long scaleCount();
+
+
+    // find High Risk Disease
+    @Query("MATCH (d:Disease) WHERE d.name in {0} RETURN d.name as name, d.high_risk as risk")
+    List<Map<String, Object>> findHighRiskDisease(List<String> diseaselist);
+
+    //get high risk
+    @Query("match(d:Disease) where d.name in {0} return d.name as name, d.high_risk as risk")
+    List<Map<String, Object>> getHighRisk(List diagList);
+
+
+    //删除诊断依据
+    //删除关系1
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition)<-[r1]-(k:Condition)<-[r2]-(h:Condition) where d.disId={0} detach delete c,k,h")
+    void deleteRelation1(Long disId);
+    //删除关系2
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition)<-[r1]-(k:Condition) where d.disId={0} detach delete c,k")
+    void deleteRelation2(Long disId);
+    //删除关系3
+    @Query("match(d:Disease)<-[r:拟诊|:确诊|:警惕]-(c:Condition) where d.disId={0} detach delete r")
+    void deleteRelation3(Long disId);
+    //删除排除关系4
+    @Query("match(d:Disease)<-[r:排除]-(l) where d.disId={0} detach delete l")
+    void deleteRelation4(Long disId);
+    //删除排除关系5
+    @Query("match(d:Disease)-[r:表现]->(j)-[r1:属于]->(k) where d.disId={0} detach delete r")
+    void deleteRelation5(Long disId);
+    //删除排除关系6
+    @Query("match(d:Disease)-[r:表现]->(j) where d.disId={0} detach delete r")
+    void deleteRelation6(Long disId);
+    //删除排除关系7
+    @Query("match(d:Disease)-[r:推荐]->(j:LIS) where d.disId={0} detach delete r")
+    void deleteRelation7(Long disId);
+    //删除排除关系8
+    @Query("match(d:Disease)-[r:推荐]->(j:PACS) where d.disId={0} detach delete r")
+    void deleteRelation8(Long disId);
+    //删除排除关系9
+    @Query("match(d:Disease)-[r:鉴别诊断]->(b) where d.disId={0} detach delete r")
+    void deleteRelation9(Long disId);
+    //删除排除关系10
+    @Query("match(c:Condition) where c.name={0} detach delete c")
+    void deleteRelation10(String conditionName);
+    //删除诊断
+    @Query("match(c:Disease) where c.disId={0} detach delete c")
+    void deleteRelation11(Long disId);
+    //更新图谱
+    //存储疾病
+    @Query("merge(d:Disease{name:{0},disId:{1},emergency:{2}})")
+    void mergeDis(String name, Long disId, Integer emergency);
+    //存储确诊，拟诊，警惕
+    @Query( "merge(c:Condition{name:{0},path:{1}})")
+    void mergeCondition(String disName, Integer path);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:确诊]->(d)")
+    void mergeQueNiHigh(String conditionName, Long disId);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:拟诊]->(d)")
+    void mergeNiHigh(String conditionName, Long disId);
+    @Query("match(c:Condition{name:{0}}),(d:Disease{disId:{1}})" +
+            " merge(c)-[:警惕]->(d)")
+    void mergeHigh(String conditionName, Long disId);
+    //任几的condition
+    @Query("merge(c:Condition{name:{0},path:{1},relation:{2}})")
+    void mergeRenCondition(String conditionName, Integer path, String relation);
+    @Query("match(c:Condition{name:{0}}),(s:Condition{name:{1}}) merge(c)-[r:诊断依据]->(s)")
+    void mergeRenCondition(String c1, String c2);
+    //具体code Condition
+    @Query("merge(c:Condition{name:{0},path:1,relation:'任一'})")
+    void mergeNUMCondition(String disName);
+    @Query("match(c:Condition{name:{0}}),(s:Condition{name:{1}}) merge(c)-[r:诊断依据]->(s)")
+    void mergeNUMCondition(String c1, String c2);
+    //开始添加所有的词语
+    //添加症状标准词
+    @Query("merge(d:Symptom{name:{0}})")
+    void mergeStandardSymptom(String name);
+    //疾病表现症状标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Symptom{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandard(Long disId, String name);
+    //属于症状标准词
+    @Query("match(d:Condition{name:{0}}),(s:Symptom{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardshuyu(String conditionName, String name);
+    //添加体征标准词
+    @Query("merge(d:Vital{name:{0}})")
+    void mergeStandardVital(String name);
+    //疾病表现体征标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Vital{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardVital(Long disId, String name);
+    //属于体征标准词
+    @Query("match(d:Condition{name:{0}}),(s:Vital{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardVitalshuyu(String conditionName, String name);
+    //添加病史标准词
+    @Query("merge(d:History{name:{0}})")
+    void mergeStandardHistory(String name);
+    //疾病表现病史标准词
+    @Query("match(d:Disease{disId:{0}}),(s:History{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardHistory(Long disId, String name);
+    //属于病史标准词
+    @Query("match(d:Condition{name:{0}}),(s:History{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardHistoryshuyu(String conditionName, String name);
+    //添加诱因标准词
+    @Query("merge(d:Cause{name:{0}})")
+    void mergeStandardCause(String name);
+    //疾病表现诱因标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Cause{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardCause(Long disId, String name);
+    //属于诱因标准词
+    @Query("match(d:Condition{name:{0}}),(s:Cause{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardCauseshuyu(String conditionName, String name);
+    //添加病程标准词
+    @Query("merge(d:Prognosis{name:{0}})")
+    void mergeStandardPrognosis(String name);
+    //疾病表现病程标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Prognosis{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardPrognosis(Long disId, String name);
+    //属于病程标准词
+    @Query("match(d:Condition{name:{0}}),(s:Prognosis{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardPrognosisshuyu(String conditionName, String name);
+    //添加其他标准词
+    @Query("merge(d:Other{name:{0}})")
+    void mergeStandardOther(String name);
+    //疾病表现其他标准词
+    @Query("match(d:Disease{disId:{0}}),(s:Other{name:{1}}) merge(d)-[r:表现]->(s)")
+    void mergeRelationStandardOther(Long disId, String name);
+    //属于其他标准词
+    @Query("match(d:Condition{name:{0}}),(s:Other{name:{1}}) merge(d)<-[r:属于]-(s)")
+    void mergeRelationStandardOthershuyu(String conditionName, String name);
+    //添加鉴别诊断
+    @Query("merge(d:DifferentDis{name:{0}})")
+    void mergeDifferentDis(String disName);
+    //疾病和鉴别诊断创建关系
+    @Query("match(d:Disease{disId:{0}}),(s:DifferentDis{name:{1}}) merge(d)-[r:鉴别诊断]->(s)")
+    void mergeRelationDifferentDis(Long disId, String name);
+    //创建公表名
+    @Query("merge(l:LIS{name:{0}})")
+    void mergePublicLIS(String lisName);
+    //疾病和鉴别诊断创建关系
+    @Query("match(d:Disease{disId:{0}}),(s:LIS{name:{1}}) merge(d)-[r:推荐]->(s)")
+    void mergeRelationLIS(Long disId, String name);
+    //创建化验结果节点
+    @Query("merge(l:LISResult{name:{0}})")
+    void mergeLISRESULT(String name);
+    //公表名和化验结果创建关系
+    @Query("match(d:LIS{name:{0}}),(s:LISResult{name:{1}}) merge(d)-[r:结果]->(s)")
+    void mergeRelationPublicLIS(String publicLis, String lisResult);
+    //化验结果和对应的codeCondition创建关系
+    @Query("match(d:Condition{name:{0}}),(s:LISResult{name:{1}}) merge(d)<-[r:诊断依据]-(s)")
+    void mergeRelationCondiLisRes(String codeCondition, String lisRes);
+    //创建辅检项目
+    @Query("merge(p:PACS{name:{0}})")
+    void mergePacs(String pacsName);
+    //疾病推荐辅检
+    @Query("match(d:Disease{disId:{0}}),(s:PACS{name:{1}}) merge(d)-[r:推荐]->(s)")
+    void mergeRelationDis2Pacs(Long disId, String name);
+    //创建辅检结果节点
+    @Query("merge(p:PACSResult{name:{0}})")
+    void mergePacsResult(String name);
+    //创建辅检和辅检结果的关系
+    @Query("match(d:PACS{name:{0}}),(s:PACSResult{name:{1}}) merge(d)-[r:结果]->(s)")
+    void mergeRelationPacsResult(String pacs, String pacsResult);
+    //辅检结果和对应的codeCondition创建关系
+    @Query("match(d:Condition{name:{0}}),(s:PACSResult{name:{1}}) merge(d)<-[r:诊断依据]-(s)")
+    void mergeRelationCondiPacsRes(String codeCondition, String pacsRes);
+}
+

graphdb/src/main/java/org/diagbot/repository/DiseaseRepository.java

@@ -140,12 +140,18 @@ public interface DiseaseRepository extends Neo4jRepository<Disease, Long> {
     //疾病和鉴别诊断创建关系
     @Query("match(d:Disease{disId:{0}}),(s:DifferentDis{name:{1}}) merge(d)-[r:鉴别诊断]->(s)")
     void mergeRelationDifferentDis(Long disId,String name);
-    //创建公表名
+    //创建化验大项
     @Query("merge(l:LIS{name:{0}})")
     void mergePublicLIS(String lisName);
-    //疾病和鉴别诊断创建关系
+    //疾病和化验大项创建关系
     @Query("match(d:Disease{disId:{0}}),(s:LIS{name:{1}}) merge(d)-[r:推荐]->(s)")
     void mergeRelationLIS(Long disId,String name);
+    //创建化验公表项
+    @Query("merge(l:PublicLIS{name:{0}})")
+    void mergePublicLIS_1(String lisName);
+    //疾病和化验公表项创建关系
+    @Query("match(d:Disease{disId:{0}}),(s:PublicLIS{name:{1}}) merge(d)-[r:推荐]->(s)")
+    void mergeRelationLIS_1(Long disId,String name);
     //创建化验结果节点
     @Query("merge(l:LISResult{name:{0}})")
     void mergeLISRESULT(String name);
@@ -155,6 +161,9 @@ public interface DiseaseRepository extends Neo4jRepository<Disease, Long> {
     //化验结果和对应的codeCondition创建关系
     @Query("match(d:Condition{name:{0}}),(s:LISResult{name:{1}}) merge(d)<-[r:诊断依据]-(s)")
     void mergeRelationCondiLisRes(String codeCondition,String lisRes);
+    //公表名和化验结果创建关系
+    @Query("match(d:LIS{name:{0}}),(s:PublicLIS{name:{1}}) merge(d)-[r:化验公表]->(s)")
+    void mergeRelationPublicAndLIS(String lis,String publicLis);
     //创建辅检项目
     @Query("merge(p:PACS{name:{0}})")
     void mergePacs(String pacsName);

graphdb/src/main/java/org/diagbot/service/KnowledgeService.java

@@ -58,5 +58,7 @@ public interface KnowledgeService {
     RespDTO deleteNeoDisease(NeoParamVO singleDisease);
     //批量插入
     RespDTO<Boolean> batchInsertDis();
+    //图谱bi统计
+    List<BiDetail> neoBi();
 
 }

graphdb/src/main/java/org/diagbot/service/impl/KnowledgeServiceImpl.java

@@ -28,10 +28,7 @@ import org.springframework.data.domain.Sort;
 import org.springframework.stereotype.Service;
 
 import java.math.RoundingMode;
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
+import java.sql.*;
 import java.text.NumberFormat;
 import java.util.*;
 
@@ -53,7 +50,8 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
     private ScaleRepository scaleRepository;
     @Autowired
     private KnowledgeMapper knowledgeMapper;
-
+    @Autowired
+    private BiRepository biRepository;
     private List<BaseNode> baseNodes;
     private String user = "teamdata";
     private String password = "jiO2rfnYhg";
@@ -399,7 +397,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
         List<String> bigdataDiagList = new LinkedList<>();//大数据诊断
         if (bigdataDiagFeature.size() > 0) {
             for (FeatureRate fe : bigdataDiagFeature) {
-                if ("neo4j".equals(fe.getSource()) && fe.getDesc().contains("确诊")) {
+                if ("neo4j".equals(fe.getSource()) && (fe.getDesc().contains("确诊") || fe.getDesc().contains("拟诊"))) {
                     neo4jDiagList.add(fe.getFeatureName());
                 } else if (fe.getDesc() == null) {
                     bigdataDiagList.add(fe.getFeatureName());
@@ -1443,7 +1441,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
         if(StringUtils.isNotEmpty(disName)){
             diseaseRepository.mergeDis(disName,disId,0);
         }else {
-            respDTO = RespDTO.onError("在数据库中没有找到"+disId+"对应的疾病！！");
+            respDTO = RespDTO.onError("在数据库中没有找到这个疾病！！");
         }
 
         //获取每个诊断依据的全部数据
@@ -1465,8 +1463,8 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
         Statement st = null;
         ResultSet rs = null;
         try {
-            String type, code ,standard,relation,result,formula,name;
-            String sql = "SELECT diagnose_id,dis_name,`type`,`code`,standard,relation,result,formula FROM `kl_diagnose_detail` where diagnose_id = "+disId+"  and is_deleted = 'N'";
+            String type, code ,standard,relation,unique_name,result,formula,name;
+            String sql = "SELECT diagnose_id,dis_name,`type`,`code`,standard,relation,unique_name,result,formula FROM `kl_diagnose_detail` where diagnose_id = "+disId+"  and is_deleted = 'N'";
             st = connection.createStatement();
             rs = st.executeQuery(sql);
             while (rs.next()){
@@ -1475,6 +1473,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
                 code = rs.getString("code");
                 standard = rs.getString("standard");
                 relation = rs.getString("relation");
+                unique_name = rs.getString("unique_name");
                 result = rs.getString("result");
                 formula = rs.getString("formula");
                 name = Type.getName(Integer.parseInt(type));
@@ -1483,6 +1482,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
                 content.put("code",code);
                 content.put("standard",standard);
                 content.put("relation",relation);
+                content.put("unique_name",unique_name);
                 content.put("result",result);
                 content.put("formula",formula);
                 contentList.add(content);
@@ -1706,6 +1706,15 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
                 }else if(ni.contains("任七")){
                     path = 7;
                     rel = "任七";
+                }else if(ni.contains("任八")){
+                    path = 8;
+                    rel = "任八";
+                }else if(ni.contains("任九")){
+                    path = 9;
+                    rel = "任九";
+                }else if(ni.contains("任十")){
+                    path = 10;
+                    rel = "任十";
                 }else {
                     path = 1;
                     rel = "任一";
@@ -1790,6 +1799,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
             String typeName = row.get("typeName");//类型对应的中文名
             String standard = row.get("standard");//标准词
             String relation = row.get("relation");//关联词
+            String unique_name = row.get("unique_name");//公表项
             String result = row.get("result");//结果
             if(StringUtils.isNotEmpty(type)){
                 String[] split =null;
@@ -1958,48 +1968,35 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
                     }
                 } else if("3".equals(type)){ //处理化验
                     String lis = "";
-                    //查找化验大项的标准词
-                    standWord = searchStandWord(standard,type,ciKu);
-                    if(StringUtils.isNotEmpty(standWord)){
-                        if(StringUtils.isNotEmpty(relation) && standard.equals(relation)){
-                            lis = standWord;
-                        }else if(StringUtils.isNotEmpty(standard) && StringUtils.isEmpty(relation)){
-                            lis = standWord;
-                        }else if(StringUtils.isNotEmpty(standard)&& StringUtils.isNotEmpty(relation)&&!standard.equals(relation)){
-                            type = "subLis";
-                            if(StringUtils.isNotEmpty(searchStandWord(relation,type,ciKu))){
-                                //查找化验小项的标准词
-                                lis = standWord+"--"+searchStandWord(relation,type,ciKu);
-                            }
-
-                        }
-                    }
-
-                    //创建公表名
+                    if(StringUtils.isNotEmpty(unique_name)){
+                        //创建化验公表项
+                        diseaseRepository.mergePublicLIS_1(unique_name);
+                        //疾病和化验公表项创建推荐关系
+                        diseaseRepository.mergeRelationLIS_1(disId,unique_name);
+                        lis =standard;
+                    //创建大项名
                     diseaseRepository.mergePublicLIS(lis);
-                    //疾病推荐化验公表名
+                    //疾病推荐化验大项名
                     diseaseRepository.mergeRelationLIS(disId,lis);
                     //处理化验结果
-                    if(StringUtils.isNotEmpty(result)){
+                    if(StringUtils.isNotEmpty(result) && StringUtils.isNotEmpty(unique_name)){
                         lisResultSplit = result.split("、");
                         if(lisResultSplit != null && lisResultSplit.length>0){
-                            //化验结果找标准词
                             for (String lisRs:lisResultSplit) {
                                 if(StringUtils.isNotEmpty(lisRs)){
-                                    lisResult = searchStandWord(lisRs,"resultLis",ciKu);
-                                    if(StringUtils.isNotEmpty(lisResult)){
-                                        //创建化验结果节点
-                                        diseaseRepository.mergeLISRESULT(lisResult);
-                                        //公表名和化验结果创建关系
-                                        diseaseRepository.mergeRelationPublicLIS(lis,lisResult);
-                                        //化验结果和对应的codeCondition创建关系
-                                        diseaseRepository.mergeRelationCondiLisRes(disName+code,lisResult);
-                                    }
-
+                                    //创建化验结果节点
+                                    diseaseRepository.mergeLISRESULT(lisRs);
+                                    //大项和化验结果创建关系
+                                    diseaseRepository.mergeRelationPublicLIS(lis,lisRs);
+                                    //化验结果和对应的codeCondition创建关系
+                                    diseaseRepository.mergeRelationCondiLisRes(disName+code,lisRs);
+                                    //化验大项和化验公表项创建关系
+//                                    diseaseRepository.mergeRelationPublicAndLIS(lis,unique_name);
                                 }
                             }
                         }
                     }
+                    }
                 }else if("4".equals(type)){ //辅检
                     //查找辅检的标准词
                     standWord = searchStandWord(standard,type,ciKu);
@@ -2076,7 +2073,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
             connect.close();
             respDTO = RespDTO.onSuc(true);
         }else {
-            respDTO = RespDTO.onError(disId +" 删除失败！！！");
+            respDTO = RespDTO.onError(" 删除失败！！！");
         }
         } catch (SQLException e) {
             e.printStackTrace();
@@ -2124,6 +2121,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
             if(disList != null && disList.size()>0){
                 for (Long disId:disList) {
                    respDTO = this.updateNeo(respDTO, disId, connect, ciKu);
+                   this.updateDate(connect,disId);
 
                 }
             }
@@ -2134,8 +2132,46 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
 
         return respDTO;
     }
-    public void updateDate(Connection connection,Long disId){
-        String sql = "UPDATE `kl_diagnose` set neo_update='1970-01-01 12:00:00' where id="+disId+";";
+
+    @Override
+    public List<BiDetail> neoBi() {
+        List<BiDetail> biDetailList = new ArrayList<>();
+        Long disCount = biRepository.diagnoseCount();
+        Long childCount = biRepository.childCount();
+        Long scaleCount = biRepository.scaleCount();
+        BiDetail dis = new BiDetail();
+        dis.setModuleName("疾病");
+        dis.setItemName("图谱推送的疾病");
+        dis.setCount(disCount);
+        BiDetail child = new BiDetail();
+        child.setModuleName("疾病");
+        child.setItemName("图谱推送的儿科疾病");
+        child.setCount(childCount);
+        BiDetail scale = new BiDetail();
+        scale.setModuleName("量表");
+        scale.setItemName("量表总数");
+        scale.setCount(scaleCount);
+        biDetailList.add(dis);
+        biDetailList.add(child);
+        biDetailList.add(scale);
+        return biDetailList;
+    }
+
+    public void updateDate(Connection connection,Long disId) throws SQLException {
+        String sql = "UPDATE `kl_diagnose` set neo_update='1970-01-01 12:00:00' where id=?";
+        PreparedStatement preparedStatement =null;
+        try {
+            connection.setAutoCommit(false);
+            preparedStatement = connection.prepareStatement(sql);
+            preparedStatement.setLong(1,disId);
+            int i = preparedStatement.executeUpdate();
+            connection.commit();
+        } catch (SQLException e) {
+            connection.rollback();
+            e.printStackTrace();
+        }finally {
+            preparedStatement.close();
+        }
     }
     public List<Long> getDisList(Connection connection){
         List<Long> disIds = new ArrayList<>();
@@ -2214,6 +2250,7 @@ public class    KnowledgeServiceImpl implements KnowledgeService {
     }
 
 
+
     public Pageable getPageable(PageVo pageVo) {
         if (pageVo.getSize() > 0) {
             if (pageVo.getSort_key() != null && pageVo.getSort_direct() != null) {

graphdb/src/main/java/org/diagbot/vo/domain/BiDetail.java

@@ -0,0 +1,31 @@
+package org.diagbot.vo.domain;
+
+public class BiDetail {
+    private String moduleName;
+    private String itemName;
+    private Long count;
+
+    public String getModuleName() {
+        return moduleName;
+    }
+
+    public void setModuleName(String moduleName) {
+        this.moduleName = moduleName;
+    }
+
+    public String getItemName() {
+        return itemName;
+    }
+
+    public void setItemName(String itemName) {
+        this.itemName = itemName;
+    }
+
+    public Long getCount() {
+        return count;
+    }
+
+    public void setCount(Long count) {
+        this.count = count;
+    }
+}

graphdb/src/main/java/org/diagbot/web/KnowledgeController.java

@@ -14,6 +14,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 import javax.validation.Valid;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
@@ -211,4 +212,14 @@ public class KnowledgeController {
         RespDTO respDTO = knowledgeService.batchInsertDis();
         return respDTO;
     }
+
+    /**
+     * 图谱的bi指标统计
+     * @return
+     */
+    @RequestMapping("/neoStatistics")
+    public List<BiDetail> biCount(){
+        List<BiDetail> biCount = knowledgeService.neoBi();
+        return biCount;
+    }
 }

graphdb/src/main/resources/application.yml

@@ -13,7 +13,7 @@ spring:
 # 驱动配置信息
   datasource:
     driver-class-name: org.neo4j.jdbc.Driver
-    url: jdbc:neo4j:http://192.168.2.123:7474
+    url: jdbc:neo4j:http://192.168.2.233:7474
     username: neo4j
     password: root
     #定义初始连接数

nlp/src/main/java/org/diagbot/nlp/rule/analyze/RuleAnalyze.java

@@ -0,0 +1,17 @@
+package org.diagbot.nlp.rule.analyze;
+
+import org.diagbot.nlp.rule.module.PreResult;
+import org.diagbot.nlp.rule.pretreat.Pretreatment;
+import org.diagbot.nlp.rule.pretreat.PretreatmentLis;
+
+import java.util.List;
+
+/**
+ * Created by louhr on 2019/9/25.
+ */
+public class RuleAnalyze {
+    public List<PreResult> lisConvert(String content) throws java.io.IOException {
+        Pretreatment pretreatment = new PretreatmentLis();
+        return pretreatment.analyze(content);
+    }
+}

common-push/src/main/java/org/diagbot/common/push/bean/PreResult.java

@@ -1,4 +1,4 @@
-package org.diagbot.common.push.bean;
+package org.diagbot.nlp.rule.module;
 
 /**
  * Created by louhr on 2019/8/31.

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/Pretreatment.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 import org.springframework.util.StringUtils;

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentDiag.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 

nlp/src/main/java/org/diagbot/nlp/rule/pretreat/PretreatmentLis.java

@@ -0,0 +1,86 @@
+package org.diagbot.nlp.rule.pretreat;
+
+import org.diagbot.nlp.participle.ParticipleUtil;
+import org.diagbot.nlp.participle.word.Lexeme;
+import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
+import org.diagbot.nlp.util.NegativeEnum;
+import org.diagbot.nlp.util.NlpUtil;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PretreatmentLis extends Pretreatment {
+    private String join_symbols = ";:；：";
+    protected NegativeEnum[] lis_result = new NegativeEnum[]{NegativeEnum.LIS_RESULT};
+    protected NegativeEnum[] lis_name = new NegativeEnum[]{NegativeEnum.LIS_NAME};
+    protected NegativeEnum[] lis_type = new NegativeEnum[]{NegativeEnum.LIS_TYPE};
+
+    public List<PreResult> analyze(String content) throws java.io.IOException {
+        List<PreResult> preResults = new ArrayList<>();
+        LexemePath<Lexeme> lexemes = ParticipleUtil.participle(content);
+        for (int i = 0; i < lexemes.size(); i++) {
+            Lexeme l = lexemes.get(i);
+            if (NlpUtil.isFeature(l.getProperty(), lis_name)) {
+                cursor = i;
+                PreResult result = new PreResult();
+                result.setDetailName(NlpUtil.concept(l, NegativeEnum.LIS_NAME));
+                result = createPreResult(lexemes, result, i);
+                if (result != null) {
+                    preResults.add(result);
+                }
+            }
+        }
+        return preResults;
+    }
+
+    public PreResult createPreResult(LexemePath<Lexeme> lexemes, Lexeme lexeme, int index) {
+        return null;
+    }
+
+    public PreResult createPreResult(LexemePath<Lexeme> lexemes, PreResult result, int index) {
+        Lexeme leftLexeme;
+        //往前查找化验套餐
+        int position = index - 1;
+        while (position > -1) {
+            leftLexeme = lexemes.get(position);
+            if (NlpUtil.isFeature(leftLexeme.getProperty(), lis_type)) {
+                result.setName(NlpUtil.concept(leftLexeme, NegativeEnum.LIS_TYPE));
+                break;
+            }
+            position--;
+        }
+        //往后查找化验结果
+        int max_find_step = 10;
+        if (index ==  lexemes.size() - 1) return null;
+        position = index++;
+        Lexeme rightLexeme;
+        while (position < (index + max_find_step) &&  position < lexemes.size()) {
+            rightLexeme = lexemes.get(position);
+            //遇上数字查找是否有单位
+            if (NlpUtil.isNumberString(rightLexeme)) {
+                result.setValue(rightLexeme.getText());
+                //继续找单位
+                int offset = 1;
+                while (offset < max_find_step && position + offset < lexemes.size()) {
+                    rightLexeme = lexemes.get(position + offset);
+                    if (NlpUtil.isFeature(rightLexeme.getProperty(), nees_time_and_unit)) {
+                        result.setUnits(rightLexeme.getText());
+                        break;
+                    }
+                    offset++;
+                }
+                break;
+            } else if (NlpUtil.isFeature(rightLexeme.getProperty(), lis_result)) {  //化验结果
+                result.setValue(rightLexeme.getText());
+                break;
+            }
+            position++;
+        }
+        return result;
+    }
+
+    public String findBodyValue(LexemePath<Lexeme> lexemes, Lexeme lexeme, int index) {
+        return null;
+    }
+}

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentMakeList.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentNormal.java

@@ -1,11 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 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.NegativeEnum;
-import org.diagbot.nlp.util.NlpUtil;
+import org.diagbot.nlp.rule.module.PreResult;
 
 import java.util.List;
 

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentOther.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentPacs.java

@@ -1,12 +1,11 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
-import org.springframework.util.StringUtils;
 
 import java.util.List;
 

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentSymptom.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 

common-push/src/main/java/org/diagbot/common/push/filter/pretreat/PretreatmentVital.java

@@ -1,9 +1,9 @@
-package org.diagbot.common.push.filter.pretreat;
+package org.diagbot.nlp.rule.pretreat;
 
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.nlp.participle.ParticipleUtil;
 import org.diagbot.nlp.participle.word.Lexeme;
 import org.diagbot.nlp.participle.word.LexemePath;
+import org.diagbot.nlp.rule.module.PreResult;
 import org.diagbot.nlp.util.NegativeEnum;
 import org.diagbot.nlp.util.NlpUtil;
 

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

@@ -3,6 +3,7 @@ package org.diagbot.nlp.util;
 import org.diagbot.nlp.participle.word.Lexeme;
 
 import java.util.*;
+import java.util.regex.Pattern;
 
 /**
  * @Auther: fyeman
@@ -39,12 +40,7 @@ public class NlpUtil {
         if (NlpUtil.isFeature(l.getProperty(), new NegativeEnum[]{NegativeEnum.NUMBER_QUANTIFIER})) {
             return true;
         }
-        for (char c : l.getText().toCharArray()) {
-            if (c >= '0' && c <= '9') {
-                return true;
-            }
-        }
-        return false;
+        return Pattern.matches("^[-\\+]?\\d+(\\.\\d+)?",l.getText());
     }
 
     public static double numberText2value(Lexeme l) {

push-web/src/main/java/org/diagbot/push/controller/AlgorithmController.java

@@ -3,17 +3,24 @@ package org.diagbot.push.controller;
 import com.alibaba.fastjson.JSONObject;
 import org.apache.commons.lang3.StringUtils;
 import org.diagbot.bigdata.work.AlgorithmCore;
+import org.diagbot.bigdata.work.ResultDataProxy;
 import org.diagbot.common.push.bean.CrisisDetail;
 import org.diagbot.common.push.bean.FeatureRate;
 import org.diagbot.common.push.bean.ResponseData;
 import org.diagbot.common.push.bean.SearchData;
-import org.diagbot.common.push.bean.neo4j.*;
+import org.diagbot.common.push.bean.neo4j.Drugs;
+import org.diagbot.common.push.bean.neo4j.Filnlly;
+import org.diagbot.common.push.bean.neo4j.MedicalIndication;
+import org.diagbot.common.push.bean.neo4j.MedicalIndicationDetail;
+import org.diagbot.common.push.bean.neo4j.Medicition;
 import org.diagbot.common.push.cache.CacheUtil;
 import org.diagbot.common.push.filter.ClassifyDiag;
 import org.diagbot.common.push.filter.rule.PretreatmentRule;
 import org.diagbot.common.push.work.ParamsDataProxy;
 import org.diagbot.graphWeb.work.GraphCalculate;
 import org.diagbot.graphWeb.work.LisPacsCalculate;
+import org.diagbot.nlp.rule.pretreat.Pretreatment;
+import org.diagbot.nlp.rule.pretreat.PretreatmentLis;
 import org.diagbot.nlp.util.Constants;
 import org.diagbot.nlp.util.NlpCache;
 import org.diagbot.pub.api.Response;
@@ -22,6 +29,7 @@ import org.diagbot.pub.utils.PropertiesUtil;
 import org.diagbot.pub.utils.http.HttpApi;
 import org.diagbot.pub.web.BaseController;
 import org.diagbot.rule.crisis.CrisisApplication;
+import org.diagbot.rule.lis.LisApplication;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Controller;
@@ -49,7 +57,7 @@ public class AlgorithmController extends BaseController {
         listView = "/pages/algorithm/list.html";
     }
 
-    @RequestMapping({"/index"})
+    @RequestMapping({ "/index" })
     public String index() {
         return listView;
     }
@@ -72,7 +80,7 @@ public class AlgorithmController extends BaseController {
         Response<ResponseData> response = new Response<>();
 
         MysqlJdbc nlpJdbc = new MysqlJdbc("root", "diagbot@20180822", "jdbc:mysql://192.168.2.235:3306/med-s?useUnicode=true&characterEncoding=UTF-8");
-        List<Map<String, String>> data = nlpJdbc.query("doc_info_validate", new String[]{"pk_dcpv", "present", "diag", "sex", "age"}, "");
+        List<Map<String, String>> data = nlpJdbc.query("doc_info_validate", new String[] { "pk_dcpv", "present", "diag", "sex", "age" }, "");
 
         Map<String, String> diags = NlpCache.getStandard_info_synonym_map().get(Constants.word_property_diagnose);
 
@@ -122,6 +130,14 @@ public class AlgorithmController extends BaseController {
     public Response<ResponseData> combine(HttpServletRequest request, SearchData searchData) throws Exception {
         ResponseData responseData = new ResponseData();
         logger.info("开始推送服务......");
+        LisApplication lisApplication = new LisApplication();
+        if ((searchData.getLisArr() == null || searchData.getLisArr().size() == 0)
+                && StringUtils.isNotEmpty(searchData.getLis())) {
+            Pretreatment pretreatment = new PretreatmentLis();
+            searchData.setLisArr(pretreatment.analyze(searchData.getLis()));
+        }
+        lisApplication.lisConvertToInputs(searchData.getLisArr(),searchData);
+
         Response<ResponseData> response = new Response();
         //一些基本信息预处理 如年龄 性别
         ParamsDataProxy paramsDataProxy = new ParamsDataProxy();
@@ -182,11 +198,13 @@ public class AlgorithmController extends BaseController {
         Map<String, List<CrisisDetail>> crisisDetails = responseData.getCrisisDetails();
         List<MedicalIndication> crisisDetailsList = this.getCrisisDetails(crisisDetails);
         List<MedicalIndication> medicalIndications = graphResponseData.getMedicalIndications();
-        if (medicalIndications == null) medicalIndications = new ArrayList<>();
+        if (medicalIndications == null) {
+            medicalIndications = new ArrayList<>();
+        }
         medicalIndications.addAll(crisisDetailsList);
         if (medicalIndications != null && medicalIndications.size() > 0) {
             logger.info("指标推送!!!!!!!!!");
-//           bigDataResponseData.getMedicalIndications().addAll(medicalIndications);
+            //           bigDataResponseData.getMedicalIndications().addAll(medicalIndications);
             bigDataResponseData.setMedicalIndications(medicalIndications);
         }
 
@@ -203,11 +221,11 @@ public class AlgorithmController extends BaseController {
         Map<String, String> vitalCache = CacheUtil.getVitalCache();
         List<String> featureList = Arrays.asList(searchData.getFeatureTypes());
         List<FeatureRate> vitals = graphResponseData.getVitals();
-        if(featureList.contains(Constants.feature_type_vital_index) && this.getVital(vitalCache,vitals).size() > 0){
-            bigDataResponseData.setVitals(this.getVital(vitalCache,vitals));
+        if (featureList.contains(Constants.feature_type_vital_index) && this.getVital(vitalCache, vitals).size() > 0) {
+            bigDataResponseData.setVitals(this.getVital(vitalCache, vitals));
 
         }
-        if(featureList.contains(Constants.feature_type_vital) && vitals.size() > 0){
+        if (featureList.contains(Constants.feature_type_vital) && vitals.size() > 0) {
             bigDataResponseData.setVitals(vitals);
         }
 
@@ -217,29 +235,33 @@ public class AlgorithmController extends BaseController {
         List<FeatureRate> classify = classifyDiag.diagClassify(upfes);
         List<FeatureRate> featureRates = classifyDiag.sortDiag(classify);
         bigDataResponseData.setDis(featureRates);
+        //返回结果化验、辅检、体征、进行性别年龄过滤
+        ResultDataProxy resultDataProxy = new ResultDataProxy();
+        resultDataProxy.resultSexAgeFilter(request, bigDataResponseData, searchData);
         response.setData(bigDataResponseData);
         return response;
     }
 
     /**
      * 包装输出的危急值
+     *
      * @param crisisDetails
      * @return
      */
-    public List<MedicalIndication> getCrisisDetails(Map<String, List<CrisisDetail>> crisisDetails){
+    public List<MedicalIndication> getCrisisDetails(Map<String, List<CrisisDetail>> crisisDetails) {
         List<MedicalIndication> crisisDetailList = new ArrayList<>();
-        for(Map.Entry<String, List<CrisisDetail>> entry : crisisDetails.entrySet()) {
-            for (CrisisDetail crisisDetail:entry.getValue()) {
+        for (Map.Entry<String, List<CrisisDetail>> entry : crisisDetails.entrySet()) {
+            for (CrisisDetail crisisDetail : entry.getValue()) {
                 String originText = crisisDetail.getOriginText();//文本输入的数据
                 String remindText = crisisDetail.getRemindText();//危机警示指标
                 String standardText = crisisDetail.getStandardText();//评判标准
-                if(StringUtils.isNotEmpty(remindText)){
+                if (StringUtils.isNotEmpty(remindText)) {
                     MedicalIndication medicalIndication = new MedicalIndication();
                     List<MedicalIndicationDetail> crisisMid = new ArrayList<>();
                     MedicalIndicationDetail medicalIndicationDetail = new MedicalIndicationDetail();
                     JSONObject jsonObject = new JSONObject();
-                    jsonObject.put("controlType",2);
-                    jsonObject.put("name",standardText);
+                    jsonObject.put("controlType", 2);
+                    jsonObject.put("name", standardText);
                     medicalIndicationDetail.setType(4);
                     medicalIndicationDetail.setContent(jsonObject);
                     crisisMid.add(medicalIndicationDetail);
@@ -252,26 +274,27 @@ public class AlgorithmController extends BaseController {
         return crisisDetailList;
     }
 
-    public List<FeatureRate> getVital(Map<String, String> vitalCache,List<FeatureRate> vitals){
+    public List<FeatureRate> getVital(Map<String, String> vitalCache, List<FeatureRate> vitals) {
         Set<String> vitalSet = new LinkedHashSet<>();
         List<FeatureRate> vitalList = new ArrayList<>();
-        if(vitals != null){
-            for (FeatureRate f:vitals) {
+        if (vitals != null) {
+            for (FeatureRate f : vitals) {
                 String s = vitalCache.get(f.getFeatureName());
-                if(StringUtils.isNotEmpty(s)){
+                if (StringUtils.isNotEmpty(s)) {
                     vitalSet.add(s);
                 }
             }
         }
-        if(vitalSet != null){
-            for (String vi:vitalSet) {
-                FeatureRate featureRate= new FeatureRate();
+        if (vitalSet != null) {
+            for (String vi : vitalSet) {
+                FeatureRate featureRate = new FeatureRate();
                 featureRate.setFeatureName(vi);
                 vitalList.add(featureRate);
             }
         }
         return vitalList;
     }
+
     public Response<ResponseData> algorithm(HttpServletRequest request, SearchData searchData) throws Exception {
         Response<ResponseData> response = new Response();
 

rule/src/main/java/org/diagbot/rule/crisis/CrisisApplication.java

@@ -1,7 +1,6 @@
 package org.diagbot.rule.crisis;
 
 import org.diagbot.common.push.bean.CrisisDetail;
-import org.diagbot.common.push.bean.PreResult;
 import org.diagbot.common.push.bean.Rule;
 import org.diagbot.common.push.bean.RuleApp;
 import org.diagbot.common.push.bean.SearchData;

rule/src/main/java/org/diagbot/rule/lis/LisApplication.java

@@ -0,0 +1,101 @@
+package org.diagbot.rule.lis;
+
+import org.diagbot.common.push.bean.SearchData;
+import org.diagbot.nlp.rule.module.PreResult;
+import org.diagbot.nlp.util.Constants;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * @Description:
+ * @Author: HUJING
+ * @Date: 2019/9/25 13:33
+ */
+public class LisApplication {
+    private static String up = "升高";
+    private static String down = "降低";
+    private static String normal = "正常";
+
+    public void lisConvertToInputs(List<PreResult> preResultList, SearchData searchData) {
+        if (preResultList == null || preResultList.size() == 0) {
+            return;
+        }
+        String covertValue = "";
+        for (PreResult result : preResultList) {
+            if (!StringUtils.isEmpty(result.getUniqueName())) {
+                //value是数值类型则进行转换
+                if (!StringUtils.isEmpty(result.getValue()) && isNumber(result.getValue())) {
+                    if (!StringUtils.isEmpty(result.getMaxValue()) && !StringUtils.isEmpty(result.getMinValue())
+                            && isNormal(result.getValue(), result.getMaxValue(), result.getMinValue())) {
+                        covertValue = result.getUniqueName() + normal;
+                    } else if (!StringUtils.isEmpty(result.getMaxValue())
+                            && compareMax(result.getValue(), result.getMaxValue())) {
+                        covertValue = result.getUniqueName() + up;
+                    } else if (!StringUtils.isEmpty(result.getMinValue())
+                            && compareMin(result.getValue(), result.getMinValue())) {
+                        covertValue = result.getUniqueName() + down;
+                    }
+                } else if (!StringUtils.isEmpty(result.getOtherValue())) {
+                    //otherValue是文本类型则直接与UniqueName拼接
+                    covertValue = result.getUniqueName() + result.getOtherValue();
+                }
+
+                Map<String, String> map = new HashMap<>();
+                map.put("featureType", Constants.feature_type_lis);
+                map.put("featureName", covertValue);
+                map.put("property", Constants.word_property_LIS_Result);
+                map.put("concept", covertValue);
+                //全是有
+                map.put("negative", Constants.default_negative);
+                if (searchData.getInputs().get(map.get("featureName")) == null) {
+                    searchData.getInputs().put(map.get("featureName"), map);
+                }
+                if (searchData.getGraphInputs().get(map.get("featureName")) == null) {
+                    searchData.getGraphInputs().put(map.get("featureName"), map);
+                }
+            }
+        }
+    }
+
+
+    private boolean isNormal(String value, String maxValue, String minValue) {
+        try {
+            return Double.valueOf(value) < Double.valueOf(maxValue) && Double.valueOf(value) > Double.valueOf(minValue);
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
+    private boolean compareMin(String value, String minValue) {
+        try {
+            return Double.valueOf(value) < Double.valueOf(minValue);
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
+    private boolean compareMax(String value, String maxValue) {
+        try {
+            return Double.valueOf(value) > Double.valueOf(maxValue);
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
+    /**
+     * 只要是整数或者是小数就是true
+     * @param value
+     * @return
+     */
+    public static boolean isNumber(String value) {
+        if (StringUtils.isEmpty(value)) {
+            return false;
+        }
+        return Pattern.matches("^[-\\+]?\\d+(\\.\\d+)?",value);
+    }
+}