Merge branch 'master' into his/yiwufubao

doc/015.20210805提示类信息规则维护支持集合分类维护/sys_user_init.sql

@@ -0,0 +1,4 @@
+USE `sys-user`;
+
+INSERT INTO `sys-user`.`sys_menu`(`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `name`, `parent_id`, `code`, `order_no`, `remark`) VALUES (104, 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '术语集合内容维护', 97, 'LT-ZSKKZWH-SYJHNRWH', 7, '朗通-知识库扩展维护-术语集合内容维护');
+INSERT INTO `sys-user`.`sys_role_menu`(`is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `role_id`, `menu_id`, `remark`) VALUES ('N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', 18, 104, '朗通-知识库扩展维护-术语集合内容维护');

doc/016.20210813化验、辅检开单互斥项修改提示语/med2021_init.sql

@@ -0,0 +1,4 @@
+USE `med_2021`;
+
+UPDATE `med_2021`.`kl_dictionary_info` SET `val`='检验项目互斥：[匹配内容]与[开单名称]不宜同时进行[原因及建议]' WHERE name='化验_开单项互斥';
+UPDATE `med_2021`.`kl_dictionary_info` SET `val`='检查项目互斥：[匹配内容]与[开单名称]不宜同时进行[原因及建议]' WHERE name='辅检_开单项互斥';

doc/017.20210823vte量表提示结果/med2021_init.sql

@@ -0,0 +1,18 @@
+USE `med_2021`;
+
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('331', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '机械医嘱', '足底静脉泵（气压治疗）', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('332', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '机械医嘱', '间歇充气加压（气压治疗）', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('333', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '机械医嘱', '医用压力弹力袜', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('334', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '机械医嘱', '气压治疗（肢体正负压治疗>=3部位', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('335', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '普通肝素', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('336', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '进口依诺肝素', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('337', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '国产依诺肝素', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('338', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '利伐沙班', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('339', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '低分子肝素', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('340', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '速碧林', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('341', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '达肝素', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('342', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '磺达肝癸钠', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('343', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '达比加群酯', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('344', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '阿加曲班', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('345', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '比伐卢定', '1', '0', 'VTE医嘱数据');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('346', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '100', '药物医嘱', '华法林1', '1', '0', 'VTE医嘱数据');

doc/018.20210824诊断依据导出/med2021_init.sql

@@ -0,0 +1,41 @@
+DROP TABLE IF EXISTS `kl_diagnose_record`;
+CREATE TABLE `kl_diagnose_record` (
+      `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
+      `is_deleted` char(1) NOT NULL DEFAULT 'N' COMMENT '是否删除,N:未删除，Y:删除',
+      `gmt_create` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录创建时间',
+      `gmt_modified` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录修改时间,如果时间是1970年则表示纪录未修改',
+      `creator` varchar(20) NOT NULL DEFAULT '0' COMMENT '创建人，0表示无创建人值',
+      `modifier` varchar(20) NOT NULL DEFAULT '0' COMMENT '修改人,如果为0则表示纪录未修改',
+      `diagnose_id` bigint(20) NOT NULL COMMENT '诊断依据主表id',
+      `type` varchar(255) NOT NULL DEFAULT '' COMMENT '类型',
+      `code` varchar(255) NOT NULL DEFAULT '' COMMENT '序号',
+      `rule` varchar(1024) NOT NULL DEFAULT '' COMMENT '规则',
+      `description` varchar(255) NOT NULL DEFAULT '' COMMENT '描述',
+      `eq_value` varchar(255) NOT NULL DEFAULT '' COMMENT '等于',
+      `max_value` varchar(255) NOT NULL DEFAULT '' COMMENT '最大值',
+      `max_operator` varchar(255) NOT NULL DEFAULT '' COMMENT '最大值符号',
+      `min_value` varchar(255) NOT NULL DEFAULT '' COMMENT '最小值',
+      `min_operator` varchar(255) NOT NULL DEFAULT '' COMMENT '最小值符号',
+      `unit` varchar(255) NOT NULL DEFAULT '' COMMENT '单位',
+      `order_no` int(11) NOT NULL DEFAULT '0' COMMENT '排序号',
+      `remark` varchar(300) NOT NULL DEFAULT '' COMMENT '备注',
+      PRIMARY KEY (`id`),
+      KEY `diagnose_id` (`diagnose_id`) USING BTREE
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='诊断依据记录表';
+
+DROP TABLE IF EXISTS `kl_diagnose_record_detail`;
+CREATE TABLE `kl_diagnose_record_detail` (
+     `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
+     `is_deleted` char(1) NOT NULL DEFAULT 'N' COMMENT '是否删除,N:未删除，Y:删除',
+     `gmt_create` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录创建时间',
+     `gmt_modified` datetime NOT NULL DEFAULT '1970-01-01 12:00:00' COMMENT '记录修改时间,如果时间是1970年则表示纪录未修改',
+     `creator` varchar(20) NOT NULL DEFAULT '0' COMMENT '创建人，0表示无创建人值',
+     `modifier` varchar(20) NOT NULL DEFAULT '0' COMMENT '修改人,如果为0则表示纪录未修改',
+     `diagnose_record_id` bigint(20) NOT NULL COMMENT '诊断依据记录表id',
+     `concept_id` bigint(20) NOT NULL DEFAULT '0' COMMENT '标准词',
+     `order_no` int(11) NOT NULL DEFAULT '0' COMMENT '排序号',
+     `remark` varchar(300) NOT NULL DEFAULT '' COMMENT '备注',
+     PRIMARY KEY (`id`),
+     KEY `diagnose_record_id` (`diagnose_record_id`) USING BTREE,
+     KEY `concept_id` (`concept_id`) USING BTREE
+) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='诊断依据记录明细表';

doc/019.20210913其他值提醒化验提示语/med2021_init.sql

@@ -0,0 +1,6 @@
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('347', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '42', '化验_药品', '该患者[化验结果]，可能正在服用[匹配内容]，请留意[原因及建议]', '1', '0', '其他值提醒化验提示语');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('348', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '42', '化验_诊断', '该患者[化验结果]，患有[匹配内容]，请留意[原因及建议]', '1', '0', '其他值提醒化验提示语');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('349', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '42', '化验_人群', '该患者[化验结果]，[匹配内容]，请留意[原因及建议]', '1', '0', '其他值提醒化验提示语');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('350', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '42', '化验_化验', '该患者[化验结果]，[匹配内容]，请留意[原因及建议]', '1', '0', '其他值提醒化验提示语');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('351', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '42', '化验_化验本身', '该患者[化验结果]，请留意[原因及建议]', '1', '0', '其他值提醒化验提示语');
+INSERT INTO `med_2021`.`kl_dictionary_info` (`id`, `is_deleted`, `gmt_create`, `gmt_modified`, `creator`, `modifier`, `group_type`, `name`, `val`, `return_type`, `order_no`, `remark`) VALUES ('352', 'N', '1970-01-01 12:00:00', '1970-01-01 12:00:00', '0', '0', '21', '其他指标提醒-实验室检查子项目', '4-108-0', '1', '0', '附加信息特殊处理(非必填)');

src/main/java/com/diagbot/aggregate/RuleAggregate.java

@@ -6,13 +6,17 @@ import com.diagbot.dto.RuleConditionDTO;
 import com.diagbot.dto.RuleConditionInitDTO;
 import com.diagbot.dto.RuleDTO;
 import com.diagbot.dto.RuleInitDTO;
+import com.diagbot.enums.BaseTypeEnum;
+import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RedisEnum;
+import com.diagbot.enums.RuleTypeEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.facade.KlRuleFacade;
 import com.diagbot.util.BeanUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RedisUtil;
 import io.github.lvyahui8.spring.annotation.DataConsumer;
 import io.github.lvyahui8.spring.annotation.DataProvider;
 import lombok.extern.slf4j.Slf4j;
@@ -35,6 +39,8 @@ import java.util.Map;
 public class RuleAggregate {
     @Autowired
     private KlRuleFacade klRuleFacade;
+    @Autowired
+    private RedisUtil redisUtil;
 
     @DataProvider("getAllRules")
     public Map<String, RuleDTO> getAllRules(
@@ -43,6 +49,8 @@ public class RuleAggregate {
             @DataConsumer("getRuleBaseInit") Map<Integer, List<RuleBaseInitDTO>> ruleBaseInits) {
         try {
             Map<String, RuleDTO> res = new HashMap();
+            //药物过敏源
+            Map<String, Integer> drugAllergen = new HashMap<>();
             //结果判空第一层规则类型
             if (MapUtils.isNotEmpty(ruleInits)) {
                 for (String ruleKey : ruleInits.keySet()) {
@@ -51,6 +59,12 @@ public class RuleAggregate {
                     ruleDTO.setLibName(ruleInitZeroDTO.getLibName());
                     ruleDTO.setLibType(ruleInitZeroDTO.getLibType());
                     ruleDTO.setRuleType(ruleInitZeroDTO.getRuleType());
+                    //药物过敏源相关
+                    Boolean allergenAdd = false;
+                    if (ruleDTO.getRuleType().equals(RuleTypeEnum.bill.getKey())
+                            && ruleDTO.getLibType().equals(LexiconEnum.Medicine.getKey())) {
+                        allergenAdd = true;
+                    }
                     Map<String, Integer> ruleConditionMap = new HashMap<>();
                     for (RuleInitDTO ruleInitDTO : ruleInits.get(ruleKey)) {
                         if (ruleInitDTO.getHasSubCond().equals(1)) {
@@ -75,6 +89,11 @@ public class RuleAggregate {
                                         //笛卡尔积
                                         List<List<RuleBaseDTO>> ruleBaseGroup = new ArrayList<>();
                                         descartes(ruleBaseList, ruleBaseGroup, 0, new ArrayList<>());
+                                        //药物过敏源相关
+                                        if (allergenAdd
+                                                && ruleBaseGroup.size() == 1) {
+                                            allergenAdd = true;
+                                        }
                                         for (List<RuleBaseDTO> ruleBaseDTOList : ruleBaseGroup) {
                                             RuleConditionDTO ruleConditionDTO1 = new RuleConditionDTO();
                                             ruleConditionDTO1.setHasSubCond(ruleConditionDTO.getHasSubCond());
@@ -83,6 +102,18 @@ public class RuleAggregate {
                                             ruleConditionDTO1.getRuleBaseDTOList().addAll(ruleBaseDTOList);
                                             if (!ruleConditionMap.containsKey(ruleConditionDTO1.toString())) {
                                                 ruleDTO.getRuleConditionDTOList().add(ruleConditionDTO1);
+                                                //药物过敏源相关
+                                                if (allergenAdd
+                                                        && ruleBaseDTOList.size() == 1) {
+                                                    RuleBaseDTO ruleBaseDTO = ruleBaseDTOList.get(0);
+                                                    if (ruleBaseDTO.getBaseType().equals(BaseTypeEnum.B4.getKey())
+                                                            && ruleDTO.getLibType().equals(ruleBaseDTO.getBaseLibType())
+                                                            && ruleDTO.getLibName().equals(ruleBaseDTO.getBaseLibName())) {
+                                                        if (!drugAllergen.containsKey(ruleDTO.getLibName())) {
+                                                            drugAllergen.put(ruleDTO.getLibName(), 1);
+                                                        }
+                                                    }
+                                                }
                                                 ruleConditionMap.put(ruleConditionDTO1.toString(), 1);
                                             }
                                         }
@@ -104,6 +135,10 @@ public class RuleAggregate {
                     }
                     res.put(RedisEnum.allRule.getName() + ruleDTO.getLibType() + "_" + ruleDTO.getLibName() + "_" + ruleDTO.getRuleType(), ruleDTO);
                 }
+                //直接加载缓存
+                if (MapUtils.isNotEmpty(drugAllergen)) {
+                    redisUtil.set(RedisEnum.drugAllergen.getName(), drugAllergen);
+                }
             }
             return res;
         } catch (Exception e) {

src/main/java/com/diagbot/client/hystrix/CRFServiceHystrix.java

@@ -1,6 +1,7 @@
 package com.diagbot.client.hystrix;
 
 import com.diagbot.client.CRFServiceClient;
+import com.diagbot.util.GsonUtil;
 import com.diagbot.vo.CRFVo;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Component;
@@ -11,7 +12,7 @@ import org.springframework.web.bind.annotation.RequestBody;
 public class CRFServiceHystrix implements CRFServiceClient {
     @Override
     public String getAnnotation(@RequestBody CRFVo crfVo) {
-        log.error("【hystrix】调用{}异常", "CRF-getAnnotation");
+        log.error("CRF解析文本【超时】或【服务出错】,参数如下{}", GsonUtil.toJson(crfVo));
         return null;
     }
 }

src/main/java/com/diagbot/config/CacheDeleteInit.java

@@ -33,8 +33,8 @@ public class CacheDeleteInit implements CommandLineRunner {
         cacheFacade.clear();
         log.info("CDSS-CORE服务启动清除redis缓存成功！");
 
-//        cacheFacade.loadDrugTypeCache();
-//        log.info("CDSS-CORE服务启动加载药品类型对应关系缓存成功！");
+       // cacheFacade.loadDrugTypeCache();
+       // log.info("CDSS-CORE服务启动加载药品类型对应关系缓存成功！");
 
         cacheFacade.getDiseaseCorrespondCache();
         log.info("CDSS-CORE服务启动加载疾病对应ICD10缓存成功！");
@@ -54,6 +54,9 @@ public class CacheDeleteInit implements CommandLineRunner {
         cacheFacade.loadMsg();
         log.info("CDSS-CORE服务启动加载开单提示语成功！");
 
+        cacheFacade.loadVteAdviceCache();
+        log.info("CDSS-CORE服务启动加载vte医嘱数据成功！");
+
         conceptInfoFacade.loadCustomDictionary();
         log.info("CDSS-CORE服务启动加载NLP分词字典成功！");
 

src/main/java/com/diagbot/dto/BaseDiagnoseDTO.java

@@ -1,15 +1,13 @@
 package com.diagbot.dto;
 
-import lombok.Getter;
-import lombok.Setter;
+import lombok.Data;
 
 /**
  * @Description:
  * @author: gaodm
  * @time: 2021/3/15 10:49
  */
-@Getter
-@Setter
+@Data
 public class BaseDiagnoseDTO {
 
     /**

src/main/java/com/diagbot/dto/DiagnoseRecordDTO.java

@@ -0,0 +1,19 @@
+package com.diagbot.dto;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * @className: com.diagbot.dto-> DiagnoseRecordDTO
+ * @description: 校验过后，都是标准词的诊断依据记录
+ * @author: kongwz
+ * @createDate: 2021-08-26 14:01
+ * @version: 1.0
+ * @todo:
+ */
+@Data
+public class DiagnoseRecordDTO extends ExportDiagnoseDTO implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private String diseaseName;
+}

src/main/java/com/diagbot/dto/ExportDiagnoseDTO.java

@@ -29,16 +29,16 @@ public class ExportDiagnoseDTO implements Serializable {
     @Excel(name="最大值", width = 10, orderNum = "50")
     private String max;
     @Excel(name="最大值符号", width = 10, orderNum = "60")
-    private String unit;
+    private String maxSymbol;
     @Excel(name="最小值", width = 10, orderNum = "70")
     private String min;
     @Excel(name="最小值符号", width = 10, orderNum = "80")
-    private String maxSymbol;
-    @Excel(name="单位", width = 10, orderNum = "90")
     private String minSymbol;
-    @Excel(name="关联词", width = 30, orderNum = "35")
+    @Excel(name="单位", width = 10, orderNum = "90")
+    private String unit;
+    @Excel(name="关联词", width = 10, orderNum = "35")
     private String relation;
-    @Excel(name="校验", width = 50, orderNum = "33")
+    @Excel(name="校验", width = 10, orderNum = "33")
     private String check;
 
 }

src/main/java/com/diagbot/dto/GetAllForRelationDTO.java

@@ -36,6 +36,12 @@ public class GetAllForRelationDTO {
     @ApiModelProperty(value="概念名称(类型)")
     private String conceptNameType;
 
+    /**
+     * 说明
+     */
+    @ApiModelProperty(value="说明（remark）")
+    private String remark;
+
 
 
 }

src/main/java/com/diagbot/dto/IndexBatchDTO.java

@@ -12,8 +12,21 @@ import lombok.Setter;
 @Setter
 public class IndexBatchDTO {
     private Long id;
+    private Integer status;
     private String name;
     private String code;
     private String synonyms;
     private Integer type;
+    /**
+     * 国药准字
+     */
+    private String approval;
+    /**
+     * 药品剂型
+     */
+    private String form;
+    /**
+     * 药品剂型id
+     */
+    private Long formConceptId;
 }

src/main/java/com/diagbot/dto/IndicationExportDTO.java

@@ -17,22 +17,22 @@ public class IndicationExportDTO implements Serializable {
 
     @Excel(name="开单名称", width = 25, orderNum = "10")
     private String parName = "";
-    @Excel(name="开单类型", width = 15, orderNum = "20")
+    @Excel(name="开单类型", width = 17, orderNum = "20")
     private String parType = "";
     @Excel(name="规则名称", width = 25, orderNum = "30")
     private String baseName = "";
-    @Excel(name="规则类型", width = 15, orderNum = "35")
+    @Excel(name="规则类型", width = 17, orderNum = "35")
     private String baseType;
-    @Excel(name="禁忌类型", width = 15, orderNum = "40")
+    @Excel(name="规则条件", width = 17, orderNum = "40")
     private String tabooType;
-    @Excel(name="最大值", width = 10, orderNum = "50")
-    private String maxValue;
-    @Excel(name="最大值符号", width = 10, orderNum = "60")
-    private String maxOperator;
-    @Excel(name="最小值", width = 10, orderNum = "70")
+    @Excel(name="最小值", width = 10, orderNum = "50")
     private String minValue;
-    @Excel(name="最小值符号", width = 10, orderNum = "80")
+    @Excel(name="最小值符号", width = 10, orderNum = "60")
     private String minOperator;
+    @Excel(name="最大值", width = 10, orderNum = "70")
+    private String maxValue;
+    @Excel(name="最大值符号", width = 10, orderNum = "80")
+    private String maxOperator;
     @Excel(name="原因及建议", width = 15, orderNum = "90")
     private String msg;
     @Excel(name="ruleId", width = 10, orderNum = "100")

src/main/java/com/diagbot/dto/KlDiagnoseRecordDTO.java

@@ -0,0 +1,89 @@
+package com.diagbot.dto;
+
+import com.google.common.collect.Lists;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * <p>
+ * 诊断依据记录表
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+@Data
+public class KlDiagnoseRecordDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 诊断依据主表id
+     */
+    private Long diagnoseId;
+
+    /**
+     * 类型
+     */
+    private String type;
+
+    /**
+     * 序号
+     */
+    private String code;
+
+    /**
+     * 规则
+     */
+    private String rule;
+
+    /**
+     * 描述
+     */
+    private String description;
+
+    /**
+     * 等于
+     */
+    private String eqValue;
+
+    /**
+     * 最大值
+     */
+    private String maxValue;
+
+    /**
+     * 最大值符号
+     */
+    private String maxOperator;
+
+    /**
+     * 最小值
+     */
+    private String minValue;
+
+    /**
+     * 最小值符号
+     */
+    private String minOperator;
+
+    /**
+     * 单位
+     */
+    private String unit;
+
+    /**
+     * 排序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 备注
+     */
+    private String remark;
+
+    // 导入记录明细
+    private List<KlDiagnoseRecordDetailDTO> recordDetailList = Lists.newArrayList();
+}

src/main/java/com/diagbot/dto/KlDiagnoseRecordDetailDTO.java

@@ -0,0 +1,39 @@
+package com.diagbot.dto;
+
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * <p>
+ * 诊断依据记录明细表
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+@Data
+public class KlDiagnoseRecordDetailDTO implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 诊断依据记录表id
+     */
+    private Long diagnoseRecordId;
+
+    /**
+     * 标准词
+     */
+    private Long conceptId;
+
+    /**
+     * 排序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

src/main/java/com/diagbot/dto/LisOtherDTO.java

@@ -13,6 +13,7 @@ import java.util.List;
 @Data
 public class LisOtherDTO {
     private String name; // 化验拼接提示语
+    private String lisNameDetail;  // 化验套餐和明细拼接，如果套餐和明细名称一样，取明细
     private String msg; // 输血名称
     private List<String> drugMsg = new ArrayList<>(); // 药品拼接提示语
     private List<String> diseaseMsg = new ArrayList<>(); // 诊断拼接提示语

src/main/java/com/diagbot/dto/MatchDTO.java

@@ -0,0 +1,14 @@
+package com.diagbot.dto;
+
+import lombok.Data;
+
+/**
+ * @description: 规则匹配内容
+ * @author: zhoutg
+ * @time: 2020/7/29 9:57
+ */
+@Data
+public class MatchDTO {
+    private String content; // 匹配内容
+    private String lisNameDetail; // 化验套餐和明细拼接，如果套餐和明细名称一样，取明细
+}

src/main/java/com/diagbot/dto/RuleSimpleDTO.java

@@ -1,15 +1,13 @@
 package com.diagbot.dto;
 
-import lombok.Getter;
-import lombok.Setter;
+import lombok.Data;
 
 /**
  * @Description: 规则扩展类
  * @author: zhoutg
  * @time: 2021/2/3 16:34
  */
-@Getter
-@Setter
+@Data
 public class RuleSimpleDTO {
     // 医院名称
     private String inputName;
@@ -27,4 +25,17 @@ public class RuleSimpleDTO {
     private String content;
     // 禁忌类型
     private String conType;
+    // 项目名称(目前用于辅检项目名称)
+    private String structName = "";
+
+    public RuleSimpleDTO() {
+    }
+
+    public RuleSimpleDTO(String inputName, String libName, String libTypeName, String content, String conType) {
+        this.inputName = inputName;
+        this.libName = libName;
+        this.libTypeName = libTypeName;
+        this.content = content;
+        this.conType = conType;
+    }
 }

src/main/java/com/diagbot/dto/WordCrfDTO.java

@@ -3,6 +3,7 @@ package com.diagbot.dto;
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.biz.push.entity.Pacs;
+import com.diagbot.biz.push.entity.Scale;
 import com.diagbot.model.label.ChiefLabel;
 import com.diagbot.model.label.DiagLabel;
 import com.diagbot.model.label.FamilyLabel;
@@ -66,13 +67,9 @@ public class WordCrfDTO {
     private DiagLabel diagLabel = new DiagLabel();
 
     /*******************************************入参数据拷贝开始******************************/
-    /**
-     * 选中诊断
-     */
+    // 选中诊断
     private Item diseaseName;
-    /**
-     * 选中手术
-     */
+    // 选中手术
     private Item operationName;
      // 诊断
     private List<Item> diag = new ArrayList<>();
@@ -90,6 +87,10 @@ public class WordCrfDTO {
     private List<ItemExt> transfusionOrder = new ArrayList<>();
     // 输血记录
     private List<ItemExt> transfusion = new ArrayList<>();
+    // 其他医嘱
+    private List<Item> otherAdvice = new ArrayList<>();
+    // 量表结果
+    private List<Scale> scale = new ArrayList<>();
     /*******************************************入参数据拷贝结束******************************/
     // 化验
     // private LisLabel lisLabel;

src/main/java/com/diagbot/entity/KlDiagnoseRecord.java

@@ -0,0 +1,118 @@
+package com.diagbot.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * <p>
+ * 诊断依据记录表
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-26
+ */
+@Data
+public class KlDiagnoseRecord implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 是否删除,N:未删除，Y:删除
+     */
+    private String isDeleted;
+
+    /**
+     * 记录创建时间
+     */
+    private Date gmtCreate;
+
+    /**
+     * 记录修改时间,如果时间是1970年则表示纪录未修改
+     */
+    private Date gmtModified;
+
+    /**
+     * 创建人，0表示无创建人值
+     */
+    private String creator;
+
+    /**
+     * 修改人,如果为0则表示纪录未修改
+     */
+    private String modifier;
+
+    /**
+     * 诊断依据主表id
+     */
+    private Long diagnoseId;
+
+    /**
+     * 类型
+     */
+    private String type;
+
+    /**
+     * 序号
+     */
+    private String code;
+
+    /**
+     * 规则
+     */
+    private String rule;
+
+    /**
+     * 描述
+     */
+    private String description;
+
+    /**
+     * 等于
+     */
+    private String eqValue;
+
+    /**
+     * 最大值
+     */
+    private String maxValue;
+
+    /**
+     * 最大值符号
+     */
+    private String maxOperator;
+
+    /**
+     * 最小值
+     */
+    private String minValue;
+
+    /**
+     * 最小值符号
+     */
+    private String minOperator;
+
+    /**
+     * 单位
+     */
+    private String unit;
+
+    /**
+     * 排序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

src/main/java/com/diagbot/entity/KlDiagnoseRecordDetail.java

@@ -0,0 +1,73 @@
+package com.diagbot.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * <p>
+ * 诊断依据记录明细表
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+@Data
+public class KlDiagnoseRecordDetail implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 是否删除,N:未删除，Y:删除
+     */
+    private String isDeleted;
+
+    /**
+     * 记录创建时间
+     */
+    private Date gmtCreate;
+
+    /**
+     * 记录修改时间,如果时间是1970年则表示纪录未修改
+     */
+    private Date gmtModified;
+
+    /**
+     * 创建人，0表示无创建人值
+     */
+    private String creator;
+
+    /**
+     * 修改人,如果为0则表示纪录未修改
+     */
+    private String modifier;
+
+    /**
+     * 诊断依据记录表id
+     */
+    private Long diagnoseRecordId;
+
+    /**
+     * 标准词
+     */
+    private Long conceptId;
+
+    /**
+     * 排序号
+     */
+    private Integer orderNo;
+
+    /**
+     * 备注
+     */
+    private String remark;
+}

src/main/java/com/diagbot/enums/LexiconEnum.java

@@ -48,6 +48,27 @@ public enum LexiconEnum implements KeyedNamed {
     SymptomClass(305,"症状类别"),
     OperationClass(306,"手术和操作类别"),
     DisSysType(307,"疾病系统分类"),
+    DiseaseCollection(308,"疾病集合"),
+    MedicineCollection(309,"药品通用名集合"),
+    FormCollection(310,"药品剂型集合"),
+    SymptomCollection(311,"症状集合"),
+    VitalCollection(312,"体格检查项目集合"),
+    VitalResultCollection(313,"体格检查结果集合"),
+    OperationCollection(314,"手术和操作集合"),
+    LisNameCollection(315,"实验室检查套餐集合"),
+    PacsNameCollection(316,"辅助检查项目集合"),
+    PacsSubNameCollection(317,"辅助检查子项目集合"),
+    PacsDescribeCollection(318,"辅助检查描述集合"),
+    PacsResultCollection(319,"辅助检查结果集合"),
+    AnesthesiaCollection(320,"麻醉集合"),
+    DeptCollection(321,"科室集合"),
+    FoodCollection(322,"食物集合"),
+    AllergenCollection(323,"其他过敏原集合"),
+    DeviceCollection(324,"医疗器械及物品集合"),
+    PartCollection(325,"部位集合"),
+    TcmdiseaseCollection(326,"中医疾病集合"),
+    TcmsyndromeCollection(327,"中医证候集合"),
+    InducementCollection(328,"诱因集合"),
     ICD10ClassNode(400,"ICD10疾病类别根节点"),
     DeptDiseaseNode(401,"科室疾病类别根节点"),
     MedChemClassNode(402,"药品化学物质类别根节点"),

src/main/java/com/diagbot/enums/RedisEnum.java

@@ -27,7 +27,10 @@ public enum RedisEnum implements KeyedNamed {
     hospitalId_(14, "hospitalId_"),
     deptPush(15, "deptPush"),
     frequency(20, "frequency"),
-    msg(21, "msg");
+    msg(21, "msg"),
+    vteAdvice(22, "vteAdvice:"),
+    drugAllergen(23, "drugAllergen"),
+    otherMsg(24, "otherMsg");
 
     @Setter
     private int key;

src/main/java/com/diagbot/enums/TypeEnum.java

@@ -21,7 +21,8 @@ public enum TypeEnum implements KeyedNamed {
     transfusion(8, "输血"),
     age(9,"年龄"),
     group(10, "人群"),
-    lisSelf(1, "化验本身");
+    lisSelf(1, "化验本身"),
+    other(11, "其他特殊规则");
 
     @Setter
     private int key;

src/main/java/com/diagbot/exception/ServiceErrorCode.java

@@ -20,8 +20,8 @@ public enum ServiceErrorCode implements ErrorCode {
     USER_EXIST("10020008", "该账号已注册"),
     EMAIL_IS_NULL("10020009", "请输入邮箱");
 
-    private String code;
-    private String msg;
+    private final String code;
+    private final String msg;
 
 
     ServiceErrorCode(String code, String msg) {
@@ -40,7 +40,7 @@ public enum ServiceErrorCode implements ErrorCode {
 
     public static ServiceErrorCode codeOf(String code) {
         for (ServiceErrorCode state : values()) {
-            if (state.getCode() == code) {
+            if (state.getCode().equals(code)) {
                 return state;
             }
         }

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

@@ -9,6 +9,9 @@ import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RuleTypeEnum;
 import com.diagbot.enums.TypeEnum;
 import com.diagbot.process.BillProcess;
+import com.diagbot.rule.DrugRule;
+import com.diagbot.rule.OtherRule;
+import com.diagbot.util.MsgNewUtil;
 import com.diagbot.util.RedisUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.vo.Drug;
@@ -36,6 +39,12 @@ public class BillFacade {
     CommonFacade commonFacade;
     @Autowired
     RedisUtil redisUtil;
+    @Autowired
+    DrugRule drugRule;
+    @Autowired
+    MsgNewUtil msgNewUtil;
+    @Autowired
+    OtherRule otherRule;
 
     /**
      * 开单合理性业务
@@ -48,6 +57,11 @@ public class BillFacade {
         List<RuleVO> ruleVOList = getRuleVO(wordCrfDTO);
         billProcess.processRule(ruleVOList, wordCrfDTO, res);
 
+        // 【特殊规则】过敏原自身过敏
+        otherRule.allergy(wordCrfDTO, res);
+        // 【特殊规则】七院：非阻塞性睡眠呼吸暂停综合征且非混合性睡眠呼吸暂停综合征，不宜同时开立睡眠呼吸监测和眼电图（EOG）（双眼）
+        otherRule.smhxjcAndYdteog(wordCrfDTO, res);
+
         // 结果去重处理
         commonFacade.dealMsg(res.getBillMsgList());
     }

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

@@ -9,8 +9,10 @@ import com.diagbot.entity.TranHospitalInfo;
 import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.enums.RedisEnum;
 import com.diagbot.enums.StandConvertEnum;
+import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.RedisUtil;
+import com.diagbot.util.StringUtil;
 import org.apache.commons.collections4.map.LinkedMap;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cache.annotation.CacheEvict;
@@ -77,7 +79,6 @@ public class CacheFacade {
     public void loadDrugTypeCache() {
         redisUtil.deleteByPrex(RedisEnum.drugType.getName());
         neoFacade.getDrugCache();
-
     }
 
     /**
@@ -117,9 +118,29 @@ public class CacheFacade {
      */
     public void loadAllRuleCache(){
         redisUtil.deleteByPrex(RedisEnum.allRule.getName());
+        redisUtil.delete(RedisEnum.drugAllergen.getName());
         neoFacade.allRuleCache();
     }
 
+    /**
+     * 缓存VTE医嘱数据
+     *
+     * @return
+     */
+    public void loadVteAdviceCache(){
+        redisUtil.deleteByPrex(RedisEnum.vteAdvice.getName());
+        // 加载
+        List<DictionaryInfoDTO> dictionaryInfoDTOList = klDictionaryInfoFacade.getListByGroupType(100);
+        if (ListUtil.isNotEmpty(dictionaryInfoDTOList)) {
+            // 提示语
+            Map<String, List<DictionaryInfoDTO>> map = EntityUtil.makeEntityListMap(dictionaryInfoDTOList, "name");
+            for (String key : map.keySet()) {
+                redisUtil.set(RedisEnum.vteAdvice.getName() + key, map.get(key).stream().map(r -> r.getVal())
+                        .filter(r -> StringUtil.isNotBlank(r)).distinct().collect(Collectors.toList()));
+            }
+        }
+    }
+
     /**
      * 重新加载大数据缓存
      *
@@ -127,10 +148,7 @@ public class CacheFacade {
      */
     public Boolean reloadPushDB(){
         PushReloadDTO pushReloadDTO = pushNewServiceClient.reloadPushDB();
-        if (pushReloadDTO == null || !pushReloadDTO.getStatus().equals(0)) {
-            return false;
-        }
-        return true;
+        return pushReloadDTO != null && pushReloadDTO.getStatus().equals(0);
     }
 
     /**
@@ -216,9 +234,8 @@ public class CacheFacade {
      * 加载提示语
      */
     public void loadMsg() {
-        // 删除
+        // 开单提示语
         redisUtil.delete(RedisEnum.msg.getName());
-        // 加载
         List<DictionaryInfoDTO> dictionaryInfoDTOList = klDictionaryInfoFacade.getListByGroupType(41);
         if (ListUtil.isNotEmpty(dictionaryInfoDTOList)) {
             // 提示语
@@ -228,5 +245,17 @@ public class CacheFacade {
             }
             redisUtil.putHashMap(RedisEnum.msg.getName(), msgMap);
         }
+
+        // 其他值提醒化验提示语
+        redisUtil.delete(RedisEnum.otherMsg.getName());
+        List<DictionaryInfoDTO> otherLisList = klDictionaryInfoFacade.getListByGroupType(42);
+        if (ListUtil.isNotEmpty(otherLisList)) {
+            // 提示语
+            Map<String, Object> msgMap = new LinkedMap<>();
+            for (DictionaryInfoDTO dic : otherLisList) {
+                msgMap.put(dic.getName(), dic.getVal());
+            }
+            redisUtil.putHashMap(RedisEnum.otherMsg.getName(), msgMap);
+        }
     }
 }

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

@@ -4,7 +4,12 @@ import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.client.CRFServiceClient;
 import com.diagbot.client.StandConvertServiceClient;
-import com.diagbot.dto.*;
+import com.diagbot.dto.BillMsg;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleExtDTO;
+import com.diagbot.dto.StandConvertCrfBatchDTO;
+import com.diagbot.dto.StandConvertCrfDTO;
+import com.diagbot.dto.WordCrfDTO;
 import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RedisEnum;
@@ -12,15 +17,39 @@ import com.diagbot.enums.StandConvertEnum;
 import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.model.ai.AIAnalyze;
+import com.diagbot.model.entity.BodyPart;
+import com.diagbot.model.entity.Clinical;
+import com.diagbot.model.entity.Modification;
 import com.diagbot.model.entity.Operation;
-import com.diagbot.model.entity.*;
-import com.diagbot.model.label.*;
+import com.diagbot.model.entity.Pacs;
+import com.diagbot.model.entity.Vital;
+import com.diagbot.model.label.ChiefLabel;
+import com.diagbot.model.label.DiagLabel;
+import com.diagbot.model.label.PacsLabel;
+import com.diagbot.model.label.PastLabel;
+import com.diagbot.model.label.PresentLabel;
+import com.diagbot.model.label.VitalLabel;
 import com.diagbot.rule.CommonRule;
-import com.diagbot.util.*;
-import com.diagbot.vo.*;
+import com.diagbot.util.AgeUtil;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.CoreUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.RedisUtil;
+import com.diagbot.util.ReflectUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.NeoPushVO;
+import com.diagbot.vo.RuleVO;
+import com.diagbot.vo.SearchData;
+import com.diagbot.vo.StandConvert;
+import com.diagbot.vo.StandConvertCrfVO;
+import com.diagbot.vo.neoPushEntity.ChiefPushVo;
 import com.diagbot.vo.neoPushEntity.Diag;
+import com.diagbot.vo.neoPushEntity.DiagVo;
 import com.diagbot.vo.neoPushEntity.Drug;
-import com.diagbot.vo.neoPushEntity.*;
+import com.diagbot.vo.neoPushEntity.LisPushVo;
+import com.diagbot.vo.neoPushEntity.PacsPushVo;
+import com.diagbot.vo.neoPushEntity.PresentPushVo;
+import com.diagbot.vo.neoPushEntity.Symptom;
 import com.google.common.collect.Lists;
 import org.apache.commons.beanutils.BeanUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -30,7 +59,11 @@ import org.springframework.stereotype.Component;
 
 import java.lang.reflect.Method;
 import java.math.BigDecimal;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 import java.util.stream.Collectors;
 
 /**
@@ -88,7 +121,7 @@ public class CommonFacade {
         if (searchData.getAgeNum() != null) {
             wordCrfDTO.setAgeNum(searchData.getAgeNum());
         } else {
-            wordCrfDTO.setAgeNum(CoreUtil.convertAge(searchData.getAge()));
+            wordCrfDTO.setAgeNum(AgeUtil.convertAge(searchData.getAge()));
         }
         wordCrfDTO.setAge(searchData.getAge());
         wordCrfDTO.setSex(searchData.getSex());
@@ -162,6 +195,12 @@ public class CommonFacade {
         if (StringUtil.isNotBlank(searchData.getVital())) {
             wordCrfDTO.setVital(searchData.getVital());
         }
+        if (ListUtil.isNotEmpty(searchData.getOtherAdvice())) {
+            wordCrfDTO.setOtherAdvice(searchData.getOtherAdvice());
+        }
+        if (ListUtil.isNotEmpty(searchData.getScale())) {
+            wordCrfDTO.setScale(searchData.getScale());
+        }
 
         // 模型处理数据
         aiAnalyze.aiProcess(searchData, wordCrfDTO);
@@ -406,8 +445,8 @@ public class CommonFacade {
         //        // 3、开单辅检项目
         //        CoreUtil.setPropertyList(wordCrfDTO.getPacsOrder(), "name", "uniqueName", map.get(StandConvertEnum.pacs.toString()));
 
-//        CoreUtil.setUninameFromDetail(wordCrfDTO.getLis(), "detailName");
-//        CoreUtil.setUninameFromDetail(wordCrfDTO.getLisOrder(), "name");
+        //        CoreUtil.setUninameFromDetail(wordCrfDTO.getLis(), "detailName");
+        //        CoreUtil.setUninameFromDetail(wordCrfDTO.getLisOrder(), "name");
         lisGetAndSet(wordCrfDTO);
         pacsGetAndSet(wordCrfDTO);
 
@@ -439,7 +478,7 @@ public class CommonFacade {
      * 类型，疾病: disease，症状: symptom，手术和操作:operation，药品: drug，实验室检查：lis，辅助检查：pacs， 辅助检查：vital"
      *
      * @param standConvert
-     * @return Map<String,Map<String,String>> -->Map<类型, Map<原始词, 标准词>>
+     * @return Map<String , Map < String , String>> -->Map<类型, Map<原始词, 标准词>>
      */
     public Map<String, Map<String, String>> standConvertCrf(StandConvert standConvert) {
         Map<String, Map<String, String>> map = new LinkedHashMap<>();
@@ -664,25 +703,25 @@ public class CommonFacade {
                 .distinct()
                 .collect(Collectors.toList());
 
-//        Map<String, Map<String, Long>> configMap = new LinkedHashMap<>();
+        //        Map<String, Map<String, Long>> configMap = new LinkedHashMap<>();
         if (ListUtil.isNotEmpty(operationList)) {
-//            configMap = tranOperationConfigFacade.getConfigMap(wordCrfDTO.getHospitalId(), operationList, null);
+            //            configMap = tranOperationConfigFacade.getConfigMap(wordCrfDTO.getHospitalId(), operationList, null);
             Map<String, Map<String, Map<String, List<String>>>> operstionMap = mappingConfigFacade.groupByHisNameWithName(operationList, ConceptTypeEnum.Operation.getKey(), wordCrfDTO.getHospitalId());
             // 1、主诉手术
-//            setListProperty(wordCrfDTO.getChiefLabel(), "operations", "standName", configMap);
-            setListProperty(wordCrfDTO.getChiefLabel(), "operations", ConceptTypeEnum.Operation.getKey(),"StandName",operstionMap);
+            //            setListProperty(wordCrfDTO.getChiefLabel(), "operations", "standName", configMap);
+            setListProperty(wordCrfDTO.getChiefLabel(), "operations", ConceptTypeEnum.Operation.getKey(), "StandName", operstionMap);
             // 2、现病史手术
-//            setListProperty(wordCrfDTO.getPresentLabel(), "operations", "standName", configMap);
-            setListProperty(wordCrfDTO.getPresentLabel(),"operations", ConceptTypeEnum.Operation.getKey(),"StandName",operstionMap);
+            //            setListProperty(wordCrfDTO.getPresentLabel(), "operations", "standName", configMap);
+            setListProperty(wordCrfDTO.getPresentLabel(), "operations", ConceptTypeEnum.Operation.getKey(), "StandName", operstionMap);
             // 3、既往史手术
-//            setListProperty(wordCrfDTO.getPastLabel(), "operations", "standName", configMap);
-            setListProperty(wordCrfDTO.getPastLabel(),"operations", ConceptTypeEnum.Operation.getKey(),"StandName",operstionMap);
+            //            setListProperty(wordCrfDTO.getPastLabel(), "operations", "standName", configMap);
+            setListProperty(wordCrfDTO.getPastLabel(), "operations", ConceptTypeEnum.Operation.getKey(), "StandName", operstionMap);
             // 4、结构化手术
-//            setListProperty(wordCrfDTO, "operation", "uniqueName", configMap);
-            setListProperty(wordCrfDTO, "operation", ConceptTypeEnum.Operation.getKey(),"UniqueName",operstionMap);
+            //            setListProperty(wordCrfDTO, "operation", "uniqueName", configMap);
+            setListProperty(wordCrfDTO, "operation", ConceptTypeEnum.Operation.getKey(), "UniqueName", operstionMap);
             // 5、手术
-//            setListProperty(wordCrfDTO, "operationOrder", "uniqueName", configMap);
-            setListProperty(wordCrfDTO, "operationOrder", ConceptTypeEnum.Operation.getKey(),"UniqueName",operstionMap);
+            //            setListProperty(wordCrfDTO, "operationOrder", "uniqueName", configMap);
+            setListProperty(wordCrfDTO, "operationOrder", ConceptTypeEnum.Operation.getKey(), "UniqueName", operstionMap);
             // 6、选中手术
             if (wordCrfDTO.getOperationName() != null &&
                     StringUtil.isNotBlank(wordCrfDTO.getOperationName().getName()) &&
@@ -702,10 +741,10 @@ public class CommonFacade {
         List<String> pacsList = new ArrayList<>();
         // 1、结构化
         CoreUtil.addList(pacsList, CoreUtil.filterUniqueList(wordCrfDTO.getPacs()));
-//        // 2、开单
+        //        // 2、开单
         CoreUtil.addList(pacsList, CoreUtil.filterUniqueList(wordCrfDTO.getPacsOrder()));
         PacsLabel pacsLabel = wordCrfDTO.getPacsLabel();
-        if(pacsLabel != null){
+        if (pacsLabel != null) {
             pacsList = pacsLabel.getItem().stream()
                     .map(x -> x.getName())
                     .collect(Collectors.toList());
@@ -713,9 +752,9 @@ public class CommonFacade {
 
         if (ListUtil.isNotEmpty(pacsList)) {
             Map<String, Map<String, Map<String, List<String>>>> pacsMap = mappingConfigFacade.groupByHisNameWithName(pacsList, ConceptTypeEnum.Pacs.getKey(), wordCrfDTO.getHospitalId());
-            setListProperty(wordCrfDTO, "pacs", ConceptTypeEnum.Pacs.getKey(),"UniqueName",pacsMap);
-            setListProperty(wordCrfDTO, "pacsOrder", ConceptTypeEnum.Pacs.getKey(),"UniqueName",pacsMap);
-            setListProperty(pacsLabel, "item", ConceptTypeEnum.Pacs.getKey(),"UniqueName",pacsMap);
+            setListProperty(wordCrfDTO, "pacs", ConceptTypeEnum.Pacs.getKey(), "UniqueName", pacsMap);
+            setListProperty(wordCrfDTO, "pacsOrder", ConceptTypeEnum.Pacs.getKey(), "UniqueName", pacsMap);
+            setListProperty(pacsLabel, "item", ConceptTypeEnum.Pacs.getKey(), "UniqueName", pacsMap);
         }
     }
 
@@ -729,7 +768,7 @@ public class CommonFacade {
         List<String> lisHisNameList = Lists.newArrayList();
         // 【所有化验】
         List<Lis> lisList = wordCrfDTO.getLis();
-        if(ListUtil.isNotEmpty(lisList)){
+        if (ListUtil.isNotEmpty(lisList)) {
             lisHisNameList.addAll(lisList
                     .stream()
                     .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
@@ -742,7 +781,8 @@ public class CommonFacade {
                 .collect(Collectors.toList());
         if (ListUtil.isNotEmpty(lisHisNameList)) {
             Map<String, Map<String, Map<String, List<String>>>> lisConfigMap = mappingConfigFacade.groupByHisNameWithName(lisHisNameList, ConceptTypeEnum.LisPack.getKey(), wordCrfDTO.getHospitalId());
-            setListProperty(wordCrfDTO, "lis", ConceptTypeEnum.LisPack.getKey(),"UniqueName",lisConfigMap);
+            setListProperty(wordCrfDTO, "lis", ConceptTypeEnum.LisPack.getKey(), "UniqueName", lisConfigMap);
+            setListProperty(wordCrfDTO, "lisOrder", ConceptTypeEnum.LisPack.getKey(), "UniqueName", lisConfigMap);
         }
 
     }
@@ -761,9 +801,9 @@ public class CommonFacade {
         ReflectUtil.setProperty(obj, listProperty, newList);
     }
 
-    public <T> void setListProperty(Object obj, String listProperty,Integer type,String propertyName, Map<String, Map<String, Map<String, List<String>>>> configMap) {
+    public <T> void setListProperty(Object obj, String listProperty, Integer type, String propertyName, Map<String, Map<String, Map<String, List<String>>>> configMap) {
         Object tList = CoreUtil.getFieldValue(obj, listProperty);
-        List<T> newList = convertStandName((List) tList,type, propertyName,configMap);
+        List<T> newList = convertStandName((List) tList, type, propertyName, configMap);
         ReflectUtil.setProperty(obj, listProperty, newList);
     }
 
@@ -825,7 +865,7 @@ public class CommonFacade {
      * @param <T>
      * @return
      */
-    public <T> List<T> convertStandName(List<T> list,Integer type,String propertyName, Map<String, Map<String, Map<String, List<String>>>> configMap) {
+    public <T> List<T> convertStandName(List<T> list, Integer type, String propertyName, Map<String, Map<String, Map<String, List<String>>>> configMap) {
         List<T> retList = new ArrayList<>();
         if (ListUtil.isEmpty(list)) {
             return list;
@@ -839,7 +879,7 @@ public class CommonFacade {
                     continue;
                 }
 
-//                String uniqueName = item.getClass().getMethod("getUniqueName").invoke(item).toString();
+                //                String uniqueName = item.getClass().getMethod("getUniqueName").invoke(item).toString();
 
                 String uniqueName = ReflectUtil.getProperty(item, "uniqueName");
                 if (StringUtil.isNotBlank(uniqueName) && !"StandName".equals(propertyName)) {
@@ -848,7 +888,7 @@ public class CommonFacade {
                 }
 
                 String hisDetailName = "";
-                if(type.equals(ConceptTypeEnum.LisPack.getKey())) {
+                if (type.equals(ConceptTypeEnum.LisPack.getKey())) {
                     hisDetailName = ReflectUtil.getProperty(item, "detailName");
                     if (StringUtil.isBlank(hisDetailName)) {
                         hisDetailName = "";
@@ -864,7 +904,7 @@ public class CommonFacade {
                                     for (String form : thirdEntry.getValue()) {
                                         T o = (T) item.getClass().newInstance();
                                         BeanUtil.copyProperties(item, o);
-                                        Method setUniqueName = o.getClass().getMethod("set"+propertyName, String.class);
+                                        Method setUniqueName = o.getClass().getMethod("set" + propertyName, String.class);
                                         setUniqueName.invoke(o, thirdEntry.getKey());
                                         Method setForm = o.getClass().getMethod("setForm", String.class);
                                         setForm.invoke(o, form);
@@ -873,29 +913,27 @@ public class CommonFacade {
                                 } else {
                                     T o = (T) item.getClass().newInstance();
                                     BeanUtil.copyProperties(item, o);
-                                    Method setUniqueName = o.getClass().getMethod("set"+propertyName, String.class);
+                                    Method setUniqueName = o.getClass().getMethod("set" + propertyName, String.class);
                                     setUniqueName.invoke(o, thirdEntry.getKey());
                                     retList.add(o);
                                 }
                             }
-
                         } else {
                             List<String> standNames = new ArrayList<>(subMap.get(hisDetailName).keySet());
                             for (String stdName : standNames) {
                                 T o = (T) item.getClass().newInstance();
                                 BeanUtil.copyProperties(item, o);
-                                Method setUniqueName = o.getClass().getMethod("set"+propertyName, String.class);
+                                Method setUniqueName = o.getClass().getMethod("set" + propertyName, String.class);
                                 setUniqueName.invoke(o, stdName);
                                 retList.add(o);
                             }
                         }
                     } else {
+                        setUniqueNameNoMapping(item, propertyName, name, hisDetailName);
                         retList.add(item);
                     }
                 } else {
-                    if (propertyName.equals("UniqueName")) {
-                        BeanUtils.copyProperty(item, "uniqueName", name);
-                    }
+                    setUniqueNameNoMapping(item, propertyName, name, hisDetailName);
                     retList.add(item);
                 }
             }
@@ -905,6 +943,28 @@ public class CommonFacade {
         return retList;
     }
 
+    /**
+     * 映射没找到，如果有细项，就用细项；无细项用套餐
+     *
+     * @param item
+     * @param propertyName
+     * @param name
+     * @param detailName
+     */
+    public <T> void setUniqueNameNoMapping(T item, String propertyName, String name, String detailName) {
+        try {
+            if (propertyName.equals("UniqueName")) {
+                if (StringUtil.isNotBlank(detailName)) {
+                    BeanUtils.copyProperty(item, "uniqueName", detailName);
+                } else {
+                    BeanUtils.copyProperty(item, "uniqueName", name);
+                }
+            }
+        } catch (Exception e) {
+
+        }
+    }
+
     /**
      * 生成给图谱的入参（推送）
      */
@@ -1082,11 +1142,11 @@ public class CommonFacade {
         getPacsStruct(pacsLabel, wordCrfDTO.getPresentLabel().getPacsLabel());
         //结构化pacs
         List<com.diagbot.biz.push.entity.Pacs> pacs = wordCrfDTO.getPacs();
-        if(ListUtil.isNotEmpty(pacs)){
-            pacs.forEach(p ->{
+        if (ListUtil.isNotEmpty(pacs)) {
+            pacs.forEach(p -> {
                 Item item = new Item();
-                item.setName(p.getName()==null?"":p.getName());
-                item.setUniqueName(p.getUniqueName()==null?"":p.getUniqueName());
+                item.setName(p.getName() == null ? "" : p.getName());
+                item.setUniqueName(p.getUniqueName() == null ? "" : p.getUniqueName());
                 pacsLabel.getItem().add(item);
             });
         }
@@ -1122,8 +1182,8 @@ public class CommonFacade {
         if (ListUtil.isNotEmpty(res.getDisease())) {
             for (Pacs pacs : res.getDisease()) {
                 Item item = new Item();
-                item.setName(pacs.getName()==null?"":pacs.getName());
-                item.setUniqueName(pacs.getStandName()==null?"":pacs.getStandName());
+                item.setName(pacs.getName() == null ? "" : pacs.getName());
+                item.setUniqueName(pacs.getStandName() == null ? "" : pacs.getStandName());
                 pacsResList.add(item);
             }
         }
@@ -1163,18 +1223,17 @@ public class CommonFacade {
      *
      * @param lises
      * @param lisList
-     *
      */
     public void getLisStruct(List<com.diagbot.model.entity.Lis> lises, List<Lis> lisList) {
         if (ListUtil.isNotEmpty(lises)) {
-                lises.stream().forEach(x -> {
-                    String bigName = x.getBigItem().getName();//大项名
-                    String detailName = x.getName();//小项名
-                    String value = x.getPd().getValue();
-                    String unit = x.getPd().getUnit();
-                    String standName = x.getStandName();
-                    lisList.add(getLis(bigName,detailName,value,unit,standName));
-                });
+            lises.stream().forEach(x -> {
+                String bigName = x.getBigItem().getName();//大项名
+                String detailName = x.getName();//小项名
+                String value = x.getPd().getValue();
+                String unit = x.getPd().getUnit();
+                String standName = x.getStandName();
+                lisList.add(getLis(bigName, detailName, value, unit, standName));
+            });
         }
     }
 

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

@@ -21,13 +21,16 @@ import com.diagbot.util.ListUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.FilterVO;
+import com.diagbot.vo.IndexByApprovalVO;
 import com.diagbot.vo.KllisDetailVO;
+import com.diagbot.vo.SearchCollectionConceptVO;
 import com.diagbot.vo.SearchConceptVO;
 import com.google.common.collect.Lists;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
@@ -68,21 +71,42 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                 return retList;
             }
             //根据id检索
-            List<KlConcept> concepts = this.list(new QueryWrapper<KlConcept>()
-                    .eq("is_deleted", IsDeleteEnum.N.getKey())
-                    //.eq("status", StatusEnum.Enable.getKey())
-                    .in("id", conceptVO.getIds()));
+            List<KlConcept> concepts = Lists.newLinkedList();
+            List<KlConcept> tempList = Lists.newLinkedList();
+            QueryWrapper<KlConcept> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
+            if (conceptVO.getStatus() != null) {
+                queryWrapper.eq("status", conceptVO.getStatus());
+                if (conceptVO.getStatus().equals(StatusEnum.Disable.getKey())) {
+                    tempList = this.list(queryWrapper);
+                    if (ListUtil.isNotEmpty(tempList)) {
+                        Map<Long, KlConcept> tempMap = tempList.stream().collect(Collectors.toMap(KlConcept::getId, v -> v));
+                        for (Map.Entry<Long, KlConcept> entry : tempMap.entrySet()) {
+                            if (conceptVO.getIds().contains(entry.getKey())) {
+                                concepts.add(entry.getValue());
+                            }
+                        }
+                    }
+                }
+            }
+            if (conceptVO.getStatus() == null || conceptVO.getStatus().equals(StatusEnum.Enable.getKey())) {
+                queryWrapper.in("id", conceptVO.getIds());
+                concepts = this.list(queryWrapper);
+            }
             for (KlConcept concept : concepts) {
                 IndexBatchDTO dto = new IndexBatchDTO();
                 dto.setId(concept.getId());
                 dto.setName(concept.getLibName());
+                dto.setStatus(concept.getStatus());
                 dto.setType(convertType(concept.getLibType(), true));
                 retList.add(dto);
             }
         } else if (conceptVO.getSource().equals(MatchSourceEnum.StandWord.getKey())) {
             QueryWrapper<KlConcept> queryWrapper = new QueryWrapper<>();
             queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
-            //.eq("status", StatusEnum.Enable.getKey());
+            if (conceptVO.getStatus() != null) {
+                queryWrapper.eq("status", conceptVO.getStatus());
+            }
             if (ListUtil.isNotEmpty(conceptVO.getNames())) {
                 queryWrapper.in("lib_name", conceptVO.getNames());
             }
@@ -99,6 +123,7 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                     IndexBatchDTO dto = new IndexBatchDTO();
                     dto.setId(concept.getId());
                     dto.setName(concept.getLibName());
+                    dto.setStatus(concept.getStatus());
                     retList.add(dto);
                 }
             }
@@ -124,10 +149,13 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                     = libratyInfos.stream().collect(Collectors.groupingBy(KlLibraryInfo::getConceptId));
             List<Long> synonymsRelatedConceptIds
                     = libratyInfos.stream().map(KlLibraryInfo::getConceptId).collect(Collectors.toList());
-            List<KlConcept> synonymsRelatedConcepts = this.list(new QueryWrapper<KlConcept>()
-                    .eq("is_deleted", IsDeleteEnum.N.getKey())
-                    //.eq("status", StatusEnum.Enable.getKey())
-                    .in("id", synonymsRelatedConceptIds));
+            QueryWrapper<KlConcept> conceptQueryWrapper = new QueryWrapper<>();
+            conceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("id", synonymsRelatedConceptIds);
+            if (conceptVO.getStatus() != null) {
+                conceptQueryWrapper.eq("status", conceptVO.getStatus());
+            }
+            List<KlConcept> synonymsRelatedConcepts = this.list(conceptQueryWrapper);
             Map<Long, KlConcept> conceptMap
                     = synonymsRelatedConcepts.stream().collect(Collectors.toMap(KlConcept::getId, v -> v));
 
@@ -142,6 +170,7 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                             IndexBatchDTO indexBatchDTO = new IndexBatchDTO();
                             indexBatchDTO.setId(concept.getId());
                             indexBatchDTO.setName(concept.getLibName());
+                            indexBatchDTO.setStatus(concept.getStatus());
                             indexBatchDTO.setSynonyms(libraryInfo.getName());
                             retList.add(indexBatchDTO);
                         }
@@ -193,10 +222,20 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                             Collectors.mapping(TcmSyndrome::getCode, Collectors.toList())));
                 }
             }
-            List<KlConcept> concepts = this.list(new QueryWrapper<KlConcept>()
+            QueryWrapper<KlConcept> klConceptQueryWrapper = new QueryWrapper<>();
+
+            klConceptQueryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                    .in("id", conceptIds);
+            if (conceptVO.getStatus() != null) {
+                klConceptQueryWrapper.eq("status", conceptVO.getStatus());
+            }
+            QueryWrapper<KlConcept> qw = new QueryWrapper<KlConcept>()
                     .eq("is_deleted", IsDeleteEnum.N.getKey())
-                    //.eq("status", StatusEnum.Enable.getKey())
-                    .in("id", conceptIds));
+                    .in("id", conceptIds);
+            if (conceptVO.getStatus() != null) {
+                qw.eq("status", conceptVO.getStatus());
+            }
+            List<KlConcept> concepts = this.list(qw);
             Map<Long, KlConcept> conceptMap
                     = concepts.stream().collect(Collectors.toMap(KlConcept::getId, v -> v));
             if (conceptMap != null && conceptMap.size() > 0) {
@@ -211,6 +250,7 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                             indexBatchDTO.setId(concept.getId());
                             indexBatchDTO.setName(concept.getLibName());
                             indexBatchDTO.setCode(code);
+                            indexBatchDTO.setStatus(concept.getStatus());
                             retList.add(indexBatchDTO);
                         }
                     }
@@ -282,14 +322,18 @@ public class KlConceptFacade extends KlConceptServiceImpl {
      */
     public List<IndexBatchDTO> filter(FilterVO filterVO) {
         List<IndexBatchDTO> retList = Lists.newArrayList();
-        List<KlConcept> klConcepts = this.list(new QueryWrapper<KlConcept>()
-                .eq("is_deleted", IsDeleteEnum.N.getKey())
-                //.eq("status", StatusEnum.Enable.getKey())
-                .like("lib_name", filterVO.getInputStr()));
+        QueryWrapper<KlConcept> queryWrapper = new QueryWrapper<>();
+        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey())
+                .like("lib_name", filterVO.getInputStr());
+        if (filterVO.getStatus() != null) {
+            queryWrapper.eq("status", filterVO.getStatus());
+        }
+        List<KlConcept> klConcepts = this.list(queryWrapper);
         for (KlConcept concept : klConcepts) {
             IndexBatchDTO indexBatchDTO = new IndexBatchDTO();
             indexBatchDTO.setId(concept.getId());
             indexBatchDTO.setName(concept.getLibName());
+            indexBatchDTO.setStatus(concept.getStatus());
             Integer type = convertType(concept.getLibType(), true);
             if (type != null) {
                 indexBatchDTO.setType(type);
@@ -299,6 +343,34 @@ public class KlConceptFacade extends KlConceptServiceImpl {
         return retList;
     }
 
+    /**
+     * 国药准字校验
+     *
+     * @param indexByApprovalVO
+     * @return
+     */
+    @Override
+    public List<IndexBatchDTO> indexByApproval(IndexByApprovalVO indexByApprovalVO) {
+        if (ListUtil.isEmpty(indexByApprovalVO.getApprovalList())) {
+            return new ArrayList<>();
+        }
+        //国药准字取字母+数字编码
+       /* String regex = "[a-zA-Z]+\\d{8}";
+        Pattern pattern = Pattern.compile(regex);
+        List<String> approvals = Lists.newArrayList();
+        for (String str : indexByApprovalVO.getApprovalList()) {
+            if (StringUtils.isBlank(str)) {
+                continue;
+            }
+            Matcher matcher = pattern.matcher(str);
+            if (matcher.find()) {
+                approvals.add(matcher.group());
+            }
+        }
+        indexByApprovalVO.setApprovalList(approvals);*/
+        return super.indexByApproval(indexByApprovalVO);
+    }
+
 
     /**
      * 类型互转
@@ -392,6 +464,28 @@ public class KlConceptFacade extends KlConceptServiceImpl {
         return retType;
     }
 
+    /**
+     * 术语集合新增
+     *
+     * @param searchConceptVO
+     * @return
+     */
+    public List<GetAllForRelationDTO> addConceptClass(SearchConceptVO searchConceptVO) {
+        List<GetAllForRelationDTO> getAllForRelationDTOS = this.searchByTypeAndNameAdd(searchConceptVO);
+        return getAllForRelationDTOS;
+    }
+
+    /**
+     * 规则维护术语查询
+     *
+     * @param searchConceptVO
+     * @return
+     */
+    public List<GetAllForRelationDTO> searchConceptRuleClass(SearchConceptVO searchConceptVO) {
+        List<GetAllForRelationDTO> getAllForRelationDTOS = this.searchByTypeAndName(searchConceptVO);
+        return getAllForRelationDTOS;
+    }
+
     public List<GetAllForRelationDTO> searchConceptByNameAndLibType(SearchConceptVO searchConceptVO) {
         List<GetAllForRelationDTO> getAllForRelationDTOS = Lists.newArrayList();
         String name = searchConceptVO.getName();
@@ -403,7 +497,8 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                     .like(StringUtil.isNotBlank(name), "lib_name", name.trim())
                     .eq("lib_type", libType)
                     .eq("status", StatusEnum.Enable.getKey())
-                    .notIn(ListUtil.isNotEmpty(excludedConceptIds), "id", excludedConceptIds));
+                    .notIn(ListUtil.isNotEmpty(excludedConceptIds), "id", excludedConceptIds)
+                    .last("limit 100"));
             if (ListUtil.isNotEmpty(conceptList)) {
                 getAllForRelationDTOS = conceptList.stream().map(x -> {
                     GetAllForRelationDTO getAllForRelationDTO = new GetAllForRelationDTO();
@@ -414,6 +509,8 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                     return getAllForRelationDTO;
                 }).collect(Collectors.toList());
             }
+
+
         }
         return getAllForRelationDTOS;
     }
@@ -423,4 +520,11 @@ public class KlConceptFacade extends KlConceptServiceImpl {
         Map<String, KllisDetailDTO> res = EntityUtil.makeEntityMap(list, "libName");
         return res;
     }
+
+
+    public List<GetAllForRelationDTO> searchCollectionConceptFac(SearchCollectionConceptVO searchCollectionConceptVO) {
+        searchCollectionConceptVO.setNames(searchCollectionConceptVO.getNames().stream().filter(x -> StringUtil.isNotBlank(x)).collect(Collectors.toList()));
+        List<GetAllForRelationDTO> getAllForRelationDTOS = this.searchCollectionConcept(searchCollectionConceptVO);
+        return getAllForRelationDTOS;
+    }
 }

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

@@ -28,7 +28,7 @@ public class KlConceptScaleFacade extends KlConceptScaleServiceImpl {
         List<KlConceptScale> list = this.list(new QueryWrapper<KlConceptScale>()
                 .in("concept_id", klScaleDetailMenuVO.getConceptId())
                 .eq("is_deleted", IsDeleteEnum.N.getKey())
-                .orderByAsc("group_num", "order_no"));
+                .orderByAsc("text_type","group_num", "order_no"));
         List<KlScaleDetailWrapper> menuList = new ArrayList<>();
         menuList = BeanUtil.listCopyTo(list, KlScaleDetailWrapper.class);
         Map<Long, List<KlScaleDetailWrapper>> menuMap = EntityUtil.makeEntityListMap(menuList, "parentId");

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

@@ -49,6 +49,7 @@ import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
@@ -339,6 +340,7 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
 
     /**
      * 静态知识检索-分页返回
+     *
      * @param staticKnowledgeIndexPageVO
      * @return
      */
@@ -418,7 +420,7 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
         List<KlConceptScale> scaleDetails = klConceptScaleFacade.list(new QueryWrapper<KlConceptScale>()
                 .eq("is_deleted", IsDeleteEnum.N.getKey())
                 .in("concept_id", conceptIds)
-                .orderByAsc("concept_id", "parent_id", "order_no"));
+                .orderByAsc("text_type", "group_num", "order_no"));
         Map<Long, List<KlConceptScale>> scaleDetailMap = scaleDetails.stream()
                 .collect(Collectors.groupingBy(KlConceptScale::getConceptId));
 
@@ -840,6 +842,7 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
 
     /**
      * 获取量表结构
+     *
      * @param conceptId
      * @return
      */
@@ -848,21 +851,21 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
         List<KlConceptScale> scaleList = klConceptScaleFacade.list(new QueryWrapper<KlConceptScale>()
                 .eq("is_deleted", IsDeleteEnum.N.getKey())
                 .eq("concept_id", conceptId)
-                .orderByAsc("parent_id", "order_no"));
+                .orderByAsc("text_type", "group_num", "order_no"));
         if (ListUtil.isEmpty(scaleList)) {
             return null;
         }
         List<ConceptScaleDetailDTO> scaleDetailList = BeanUtil.listCopyTo(scaleList, ConceptScaleDetailDTO.class);
         if (null != scaleVO) {
             List<String> codeList = new ArrayList<>();
-            codeList= scaleDetailList.stream().filter(s -> StringUtils.isNotBlank(s.getRuleCode())).map(ac -> ac.getRuleCode()).collect(Collectors.toList());
+            codeList = scaleDetailList.stream().filter(s -> StringUtils.isNotBlank(s.getRuleCode())).map(ac -> ac.getRuleCode()).collect(Collectors.toList());
             scaleVO.setCodeList(codeList);
             ScaleDTO scaleDTO = klRegulationBaseFacade.process(scaleVO);
             List<String> codeListNew = scaleDTO.getCodeList(); //Arrays.asList("100001", "100013");
             if (ListUtil.isNotEmpty(codeListNew)) {
                 for (String str : codeListNew) {
                     for (ConceptScaleDetailDTO data2 : scaleDetailList) {
-                        if (null!=data2.getRuleCode()&&data2.getRuleCode().equals(str)) {
+                        if (null != data2.getRuleCode() && data2.getRuleCode().equals(str)) {
                             data2.setMatch(1);
                         }
                     }
@@ -879,7 +882,7 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
             if (ListUtil.isNotEmpty(codeListNew)) {
                 for (String str : codeListNew) {
                     for (ConceptScaleDetailDTO data2 : scaleDetailList) {
-                        if (null!=data2.getRuleCode()&&data2.getRuleCode().equals(str)) {
+                        if (null != data2.getRuleCode() && data2.getRuleCode().equals(str)) {
                             data2.setMatch(1);
                         }
                     }
@@ -888,7 +891,7 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
         }
 
         Map<Long, List<ConceptScaleDetailDTO>> parentMap
-                = scaleDetailList.stream().collect(Collectors.groupingBy(ConceptScaleDetailDTO::getParentId));
+                = scaleDetailList.stream().sorted(Comparator.comparing(ConceptScaleDetailDTO::getTextType).thenComparing(ConceptScaleDetailDTO::getGroupNum)).collect(Collectors.groupingBy(ConceptScaleDetailDTO::getParentId));
         List<ConceptScaleDetailDTO> retScacleDetailList = parentMap.get(-1L);
         if (ListUtil.isEmpty(retScacleDetailList)) {
             return null;
@@ -905,13 +908,24 @@ public class KlConceptStaticFacade extends KlConceptStaticServiceImpl {
         for (ConceptScaleSubDTO subDTO : retList) {
             scaleRecursion(subDTO, parentMap);
         }
+        //排序
+        for (ConceptScaleSubDTO data : retList) {
+            if (ListUtil.isNotEmpty(data.getDetailList())) {
+                for (ConceptScaleDetailDTO datasub : data.getDetailList()) {
+                    if (ListUtil.isNotEmpty(datasub.getSubList())) {
+                        datasub.setSubList(datasub.getSubList().stream().sorted(Comparator.comparing(ConceptScaleSubDTO::getGroupNum)).collect(Collectors.toList()));
+                    }
 
+                }
+            }
+        }
         retDTO.setScaleDetails(retList);
         return retDTO;
     }
 
     /**
      * 递归
+     *
      * @param item
      * @param treeMap
      */

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

@@ -1,6 +1,7 @@
 package com.diagbot.facade;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.DiagnoseRecordDTO;
 import com.diagbot.dto.ExportDescDTO;
 import com.diagbot.dto.ExportDiagnoseDTO;
 import com.diagbot.dto.ExportDiagnoseNameDTO;
@@ -10,6 +11,7 @@ import com.diagbot.enums.CommonEnum;
 import com.diagbot.enums.DiagnoseLexiconTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.service.KlDiagnoseDetailService;
+import com.diagbot.service.KlDiagnoseRecordService;
 import com.diagbot.service.KlLibraryInfoService;
 import com.diagbot.util.*;
 import com.google.common.collect.Lists;
@@ -46,16 +48,34 @@ public class KlDiagnoseDetailFacade {
     @Qualifier("klDiagnoseDetailServiceImpl")
     private KlDiagnoseDetailService klDiagnoseDetailService;
 
+    @Autowired
+    @Qualifier("klDiagnoseRecordServiceImpl")
+    KlDiagnoseRecordService klDiagnoseRecordService;
+
     /**
-     * 导出诊断依据【初版】
+     * 导出诊断依据【旧诊断依据】，从原detail导出
      */
-    public void exportDiagnose(HttpServletResponse response) {
+    public void exportDiagnoseDetail(HttpServletResponse response) {
         // 获取全部数据、分组
-        List<KlDiagnoseDetail> klDiagnoseDetailList = klDiagnoseDetailService.list(new QueryWrapper<KlDiagnoseDetail>()
-//                .eq("dis_name", "急性化脓性扁桃体炎")
-                .eq("is_deleted", IsDeleteEnum.N.getKey()));
-        Map<String, List<KlDiagnoseDetail>> diagnoseDetailMap = EntityUtil.makeEntityListMap(klDiagnoseDetailList, "disName");
-        Map<String, List<ExportDiagnoseDTO>> diagnoseDetails = processDiagnoseDetail(diagnoseDetailMap);
+       List<KlDiagnoseDetail> klDiagnoseDetailList = klDiagnoseDetailService.list(new QueryWrapper<KlDiagnoseDetail>()
+               .eq("is_deleted", IsDeleteEnum.N.getKey()));
+       Map<String, List<KlDiagnoseDetail>> diagnoseDetailMap = EntityUtil.makeEntityListMap(klDiagnoseDetailList, "disName");
+       Map<String, List<ExportDiagnoseDTO>> diagnoseDetails = processDiagnoseDetail(diagnoseDetailMap);
+       exportDiagnoseCommon(response, diagnoseDetails);
+    }
+
+    /**
+     * 导出诊断依据【新诊断依据】，从记录导出
+     */
+    public void exportDiagnoseRecord(HttpServletResponse response) {
+        Map<String, List<ExportDiagnoseDTO>> diagnoseDetails = exportDiagnoseRecord();
+        exportDiagnoseCommon(response, diagnoseDetails);
+    }
+
+    /**
+     * 导出诊断依据【初版】
+     */
+    public void exportDiagnoseCommon(HttpServletResponse response, Map<String, List<ExportDiagnoseDTO>> diagnoseDetails) {
         List<ExportDiagnoseDTO> res = new ArrayList<>();
         for (String disName : diagnoseDetails.keySet()) {
             ExportDiagnoseDTO exportDiagnoseDTO = new ExportDiagnoseDTO();
@@ -101,6 +121,18 @@ public class KlDiagnoseDetailFacade {
         ExcelUtils.exportExcel(exportDto, "diagnose.xlsx", response);
     }
 
+    public Map<String, List<ExportDiagnoseDTO>> exportDiagnoseRecord() {
+        List<DiagnoseRecordDTO> diagnoseRecord = klDiagnoseRecordService.getDiagnoseRecord();
+        Map<String, List<DiagnoseRecordDTO>> diseaseRecordMap = EntityUtil.makeEntityListMap(diagnoseRecord, "diseaseName");
+        Map<String, List<ExportDiagnoseDTO>> diagnoseDetails = new LinkedHashMap<>();
+        diseaseRecordMap.forEach((x,y) -> diagnoseDetails.put(x,y.stream().map(z ->{
+            ExportDiagnoseDTO exportDiagnoseDTO = new ExportDiagnoseDTO();
+            BeanUtil.copyProperties(z,exportDiagnoseDTO);
+            return exportDiagnoseDTO;
+        }).collect(Collectors.toList())));
+        return diagnoseDetails;
+    }
+
 
     public Map<String, List<ExportDiagnoseDTO>> processDiagnoseDetail(Map<String, List<KlDiagnoseDetail>> diagnoseDetailMap) {
         Map<String, List<ExportDiagnoseDTO>> data = new LinkedHashMap<>();
@@ -312,6 +344,6 @@ public class KlDiagnoseDetailFacade {
         String pateern = "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])";
         String content = formulas.stream().collect(Collectors.joining(","));
         //获取公式中的编码
-        return RegexUtil.getRegexDatas(content, pateern);
+        return RegexUtil.getRegexDataAll(content, pateern);
     }
 }

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

@@ -1,14 +1,17 @@
 package com.diagbot.facade;
 
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.diagbot.dto.KlDiagnoseRecordDTO;
+import com.diagbot.dto.KlDiagnoseRecordDetailDTO;
 import com.diagbot.entity.KlConcept;
 import com.diagbot.entity.KlDiagnose;
-import com.diagbot.enums.CommonEnum;
-import com.diagbot.enums.DiagnoseLexiconTypeEnum;
-import com.diagbot.enums.IsDeleteEnum;
-import com.diagbot.enums.LexiconEnum;
-import com.diagbot.enums.LexiconExtEnum;
+import com.diagbot.entity.KlDiagnoseRecord;
+import com.diagbot.entity.KlDiagnoseRecordDetail;
+import com.diagbot.enums.*;
 import com.diagbot.service.KlConceptService;
+import com.diagbot.service.KlDiagnoseRecordDetailService;
+import com.diagbot.service.KlDiagnoseRecordService;
+import com.diagbot.util.BeanUtil;
 import com.diagbot.util.CoreUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
@@ -32,7 +35,6 @@ import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.stereotype.Component;
 import org.springframework.web.multipart.MultipartFile;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -55,6 +57,12 @@ public class KlDiagnoseImportFacade {
     private KlConceptService klConceptService;
     @Autowired
     KlDiagnoseFacade klDiagnoseFacade;
+    @Autowired
+    @Qualifier("klDiagnoseRecordServiceImpl")
+    KlDiagnoseRecordService klDiagnoseRecordService;
+    @Autowired
+    @Qualifier("klDiagnoseRecordDetailServiceImpl")
+    KlDiagnoseRecordDetailService klDiagnoseRecordDetailService;
 
     public Map<String, Object> importDiagnose(MultipartFile file, DiagnoseImportVO diagnoseImportVO) {
         long t1 = System.currentTimeMillis();
@@ -70,12 +78,20 @@ public class KlDiagnoseImportFacade {
         // 保存数据
         if (allFlag) {
             saveData(allData);
-            message.put("导入条数", allData.size() + "条");
-            // 如果有指定诊断，提示导入的诊断；如果全部导入，提示“所有诊断”
+            long sucCount = allData.stream().filter(r -> ListUtil.isNotEmpty(r.getImportDiagnoseVOList())).count();
+            long emptyCount = allData.stream().filter(r -> ListUtil.isEmpty(r.getImportDiagnoseVOList())).count();
+            message.put("总条数", allData.size() + "条");
+            if (sucCount != 0L) {
+                message.put("成功导入条数", sucCount + "条");
+            }
+            if (emptyCount != 0L) {
+                message.put("空诊断依据条数", emptyCount + "条");
+                List<String> disNameList = allData.stream().filter(r -> ListUtil.isEmpty(r.getImportDiagnoseVOList())).map(r -> r.getDiseaseName()).collect(Collectors.toList());
+                message.put("空诊断依据", StringUtils.join(disNameList, CommonEnum.splitSymbol.getName()));
+            }
+            // 如果有指定诊断，提示导入的诊断；
             if (ListUtil.isNotEmpty(diagnoseImportVO.getDiags())) {
                 message.put("导入诊断", allData.stream().map(r -> r.getDiseaseName()).collect(Collectors.joining(CommonEnum.splitSymbol.getName())));
-            } else {
-                message.put("导入诊断", "所有诊断");
             }
         }
         long t2 = System.currentTimeMillis();
@@ -95,7 +111,7 @@ public class KlDiagnoseImportFacade {
     public Boolean verifyData(MultipartFile file, DiagnoseImportVO diagnoseImportVO, Map<String, Object> diagMessage, List<ImportDiagnoseResVO> allData) {
         Boolean allFlag = true;
         List<String> diagtypes = Lists.newArrayList("拟诊", "确诊", "警惕");
-        List<String> splitType = Lists.newArrayList("症状", "体格检查结果", "疾病", "人群", "辅助检查结果");
+        List<String> splitType = Lists.newArrayList("症状", "体格检查结果", "疾病", "人群", "辅助检查结果", "实验室检查子项目");
         // 获取标准词库Map
         Map<String, KlConcept> concept_map = getConceptMap();
 
@@ -152,6 +168,43 @@ public class KlDiagnoseImportFacade {
                 // 添加到正确数据列表
                 importDiagnoseResVO.setImportDiagnoseVOList(curData);
                 allData.add(importDiagnoseResVO);
+
+                // 存放记录和记录明细
+                List<ImportDiagnoseVO> importDiagnoseVOS = groupData.get(disName);
+                List<KlDiagnoseRecordDTO> klDiagnoseRecordList = Lists.newArrayList();
+                int recordOrder = 1;
+                List<Integer> rowIds = Lists.newArrayList();
+                for (ImportDiagnoseVO importDiagnoseVO : importDiagnoseVOS) {
+                    if (rowIds.contains(importDiagnoseVO.getRowNum())) {
+                        continue;
+                    }
+                    KlDiagnoseRecordDTO klDiagnoseRecordDTO = new KlDiagnoseRecordDTO();
+                    BeanUtil.copyProperties(importDiagnoseVO, klDiagnoseRecordDTO);
+                    klDiagnoseRecordDTO.setCode(importDiagnoseVO.getOrderNo());
+                    if ("确诊".equals(importDiagnoseVO.getType())) {
+                        if (StringUtil.isNotBlank(importDiagnoseVO.getParentRule())) {
+                            klDiagnoseRecordDTO.setRule(importDiagnoseVO.getParentRule());
+                        }
+                    }
+                    klDiagnoseRecordDTO.setOrderNo(recordOrder);
+                    klDiagnoseRecordList.add(klDiagnoseRecordDTO);
+                    if (ListUtil.isNotEmpty(importDiagnoseVO.getConceptId())) {
+                        int detailOrder = 1;
+                        List<KlDiagnoseRecordDetailDTO> klDiagnoseRecordDetailList = Lists.newArrayList();
+                        for (Long id : importDiagnoseVO.getConceptId()) {
+                            KlDiagnoseRecordDetailDTO klDiagnoseRecordDetailDTO = new KlDiagnoseRecordDetailDTO();
+                            klDiagnoseRecordDetailDTO.setConceptId(id);
+                            klDiagnoseRecordDetailDTO.setOrderNo(detailOrder);
+                            BeanUtil.copyProperties(importDiagnoseVO, klDiagnoseRecordDetailDTO);
+                            klDiagnoseRecordDetailList.add(klDiagnoseRecordDetailDTO);
+                            detailOrder++;
+                        }
+                        klDiagnoseRecordDTO.setRecordDetailList(klDiagnoseRecordDetailList);
+                    }
+                    recordOrder++;
+                    rowIds.add(importDiagnoseVO.getRowNum());
+                }
+                importDiagnoseResVO.setRecordList(klDiagnoseRecordList);
             } else {
                 allFlag = false;
                 diagMessage.put(disName, StringUtils.join(currentErrMsg.stream().distinct().collect(Collectors.toList()), "；  "));
@@ -193,7 +246,7 @@ public class KlDiagnoseImportFacade {
                             importDiagnoseVO.setParentRule(next.getRule());
                             importDiagnoseVO.setType(type);
                             importDiagnoseVO.setRowNum(rowNum);
-                            importDiagnoseVO.setOrderNo(rule.replace("拟诊", nizhen));
+                            importDiagnoseVO.setRule(rule.replace("拟诊", nizhen));
                             it.add(importDiagnoseVO);
                         }
                     }
@@ -244,7 +297,7 @@ public class KlDiagnoseImportFacade {
             if (StringUtil.isBlank(type) && StringUtil.isBlank(orderNo)) {
                 continue;
             }
-            if (!type.contains("正则") && !diagtypes.contains(type) && splitType.contains(type)) {
+            if (!type.contains("正则") && !diagtypes.contains(type)) {
                 List<String> splits = CoreUtil.getSplit(rule);
                 if (ListUtil.isNotEmpty(splits)) {
                     List<Long> conceptIds = Lists.newArrayList();
@@ -277,9 +330,9 @@ public class KlDiagnoseImportFacade {
                 String type = imd.getType();
                 String rule = imd.getRule();
                 String orderNo = imd.getOrderNo();
-                String eq = imd.getEq();
-                String maxSymbol = imd.getMaxSymbol();
-                String minSymbol = imd.getMinSymbol();
+                String eq = imd.getEqValue();
+                String maxSymbol = imd.getMaxOperator();
+                String minSymbol = imd.getMinOperator();
                 String parentRule = imd.getParentRule();
                 if (StringUtil.isBlank(type) && StringUtil.isBlank(orderNo)) {
                     continue;
@@ -324,7 +377,7 @@ public class KlDiagnoseImportFacade {
                 }
                 if ((LexiconExtEnum.Vital.getName().equals(type) || LexiconExtEnum.Age.getName().equals(type))
                         && StringUtils.isNotBlank(rule)
-                        && StringUtils.isBlank(imd.getMin()) && StringUtils.isBlank(imd.getMax())) {
+                        && StringUtils.isBlank(imd.getMinValue()) && StringUtils.isBlank(imd.getMaxValue())) {
                     currentErrMsg.add(String.format("第%d行%s【最大值】和【最小值】至少有一个不能为空", rowNum, rule));
                 }
                 if (StringUtils.isBlank(type)) {
@@ -365,6 +418,7 @@ public class KlDiagnoseImportFacade {
         List<KlConcept> klConcepts
                 = klConceptService.list(new QueryWrapper<KlConcept>()
                 .eq("is_deleted", IsDeleteEnum.N.getKey())
+                .eq("status", StatusEnum.Enable.getKey())
         );
         Map<String, KlConcept> map
                 = EntityUtil.makeEntityMapByKeys(klConcepts, "_", "libName", "libType");
@@ -429,6 +483,39 @@ public class KlDiagnoseImportFacade {
                     klDiagnoseSaveVO.setModifier("0");
                 }
                 klDiagnoseFacade.saveDiagnoseAll(klDiagnoseSaveVO);
+
+                //  保存记录表和记录明细表
+                List<KlDiagnoseRecordDTO> recordList = importDiagnoseResVO.getRecordList();
+                List<KlDiagnoseRecord> klDiagnoseRecordList = klDiagnoseRecordService.list(new QueryWrapper<KlDiagnoseRecord>()
+                        .eq("diagnose_id", klDiagnoseSaveVO.getId()));
+                if (ListUtil.isNotEmpty(klDiagnoseRecordList)) {
+                    List<Long> recordIdList = klDiagnoseRecordList.stream().map(r -> r.getId()).collect(Collectors.toList());
+                    // 先删除记录明细表
+                    klDiagnoseRecordDetailService.remove(new QueryWrapper<KlDiagnoseRecordDetail>()
+                            .in("diagnose_record_id", recordIdList));
+                    // 再删除记录表
+                    klDiagnoseRecordService.remove(new QueryWrapper<KlDiagnoseRecord>().in("id", recordIdList));
+                }
+                for (KlDiagnoseRecordDTO klDiagnoseRecordDTO : recordList) {
+                    // 保存记录表
+                    KlDiagnoseRecord klDiagnoseRecord = new KlDiagnoseRecord();
+                    BeanUtil.copyProperties(klDiagnoseRecordDTO, klDiagnoseRecord);
+                    klDiagnoseRecord.setDiagnoseId(klDiagnoseSaveVO.getId());
+                    klDiagnoseRecordService.save(klDiagnoseRecord);
+
+                    // 保存记录明细表
+                    List<KlDiagnoseRecordDetailDTO> recordDetailList = klDiagnoseRecordDTO.getRecordDetailList();
+                    if (ListUtil.isNotEmpty(recordDetailList)) {
+                        List<KlDiagnoseRecordDetail> recorlDetailList = Lists.newArrayList();
+                        for (KlDiagnoseRecordDetailDTO detailDTO : recordDetailList) {
+                            KlDiagnoseRecordDetail klDiagnoseRecordDetail = new KlDiagnoseRecordDetail();
+                            BeanUtil.copyProperties(detailDTO, klDiagnoseRecordDetail);
+                            klDiagnoseRecordDetail.setDiagnoseRecordId(klDiagnoseRecord.getId());
+                            recorlDetailList.add(klDiagnoseRecordDetail);
+                        }
+                        klDiagnoseRecordDetailService.saveBatch(recorlDetailList);
+                    }
+                }
             }
         }
     }
@@ -530,29 +617,29 @@ public class KlDiagnoseImportFacade {
                     case Vital: // 体格检查项目
                     case Age: // 年龄
                         klDiagnoseDetailVO.setBasConceptId(current.getConceptId());
-                        if (StringUtil.isNotBlank(current.getMin())) {
-                            klDiagnoseDetailVO.setMinVal(current.getMin());
+                        if (StringUtil.isNotBlank(current.getMinValue())) {
+                            klDiagnoseDetailVO.setMinVal(current.getMinValue());
                         }
-                        if (StringUtil.isNotBlank(current.getMinSymbol())) {
-                            klDiagnoseDetailVO.setMinOperator(current.getMinSymbol());
+                        if (StringUtil.isNotBlank(current.getMinOperator())) {
+                            klDiagnoseDetailVO.setMinOperator(current.getMinOperator());
                         }
                         if (StringUtil.isNotBlank(current.getUnit())) {
                             klDiagnoseDetailVO.setMinUnit(current.getUnit());
                             klDiagnoseDetailVO.setMaxUnit(current.getUnit());
                         }
-                        if (StringUtil.isNotBlank(current.getMax())) {
-                            klDiagnoseDetailVO.setMaxVal(current.getMax());
+                        if (StringUtil.isNotBlank(current.getMaxValue())) {
+                            klDiagnoseDetailVO.setMaxVal(current.getMaxValue());
                         }
-                        if (StringUtil.isNotBlank(current.getMaxSymbol())) {
-                            klDiagnoseDetailVO.setMaxOperator(String.valueOf(current.getMaxSymbol()));
+                        if (StringUtil.isNotBlank(current.getMaxOperator())) {
+                            klDiagnoseDetailVO.setMaxOperator(String.valueOf(current.getMaxOperator()));
                         }
                         klDiagnoseDetailVO.setBasDescription(current.getRule());
                         klDiagnoseDetailVO.setBasType(2);
                         break;
                     case LisSubName: // 实验室检查子项目
                         klDiagnoseDetailVO.setBasConceptId(current.getConceptId());
-                        klDiagnoseDetailVO.setEqValue(current.getEq());
-                        klDiagnoseDetailVO.setBasDescription(current.getRule() + current.getEq());
+                        klDiagnoseDetailVO.setEqValue(current.getEqValue());
+                        klDiagnoseDetailVO.setBasDescription(current.getRule() + current.getEqValue());
                         klDiagnoseDetailVO.setBasType(2);
                         break;
                 }

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

@@ -38,8 +38,6 @@ import io.github.lvyahui8.spring.facade.DataFacade;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections.MapUtils;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Qualifier;
-import org.springframework.data.redis.core.RedisTemplate;
 import org.springframework.stereotype.Component;
 
 import java.util.ArrayList;
@@ -67,9 +65,6 @@ public class NeoFacade {
     @Autowired
     RedisUtil redisUtil;
     @Autowired
-    @Qualifier("redisTemplateForSimilar")
-    RedisTemplate redisTemplate;
-    @Autowired
     SymptomFeatureService symptomFeatureService;
     @Autowired
     KlDiseaseCorrespondingService klDiseaseCorrespondingService;
@@ -102,7 +97,7 @@ public class NeoFacade {
                 Collectors.toMap(k -> RedisEnum.drugType.getName() + k.getDrugType(),
                         v -> v.getDrugs(), (v1, v2) -> (v2)));
         if (redisMap != null && redisMap.size() > 0) {
-            redisTemplate.opsForValue().multiSet(redisMap);
+            redisUtil.multiSet(redisMap);
         }
     }
 
@@ -120,7 +115,7 @@ public class NeoFacade {
                     },
                     (v1, v2) -> (v2)
             ));
-            redisTemplate.opsForValue().multiSet(map);
+            redisUtil.multiSet(map);
         }
     }
 
@@ -135,7 +130,7 @@ public class NeoFacade {
                 Map<String, Long> collect = y.stream().collect(Collectors.toMap(TranHospitalFilter::getUniqueName, TranHospitalFilter::getDocNum, (existing, replacement) -> replacement));
                 data.put(RedisEnum.diseaseFilter.getName() + x.toString(), collect);
             });
-            redisTemplate.opsForValue().multiSet(data);
+            redisUtil.multiSet(data);
         }
     }
 
@@ -159,7 +154,7 @@ public class NeoFacade {
                     },
                     (v1, v2) -> (v2)
             ));
-            redisTemplate.opsForValue().multiSet(map);
+            redisUtil.multiSet(map);
         }
     }
 
@@ -499,7 +494,7 @@ public class NeoFacade {
         try {
             Map<String, Object> invokeParams = new HashMap<>();
             Map<String, RuleDTO> map = DataFacade.get("getAllRules", invokeParams, Map.class);
-            redisTemplate.opsForValue().multiSet(map);
+            redisUtil.multiSet(map);
         } catch (Exception e) {
             throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "获取所有规则失败" + e.getMessage());
         }
@@ -508,14 +503,14 @@ public class NeoFacade {
     public void allBaseDiagnose() {
         List<BaseDiagnoseDTO> list = klDiagnoseBaseFacade.getAllBaseDiagnose();
         if (ListUtil.isNotEmpty(list)) {
-            redisTemplate.opsForValue().set(RedisEnum.allBaseDiagnose.getName(), list);
+            redisUtil.set(RedisEnum.allBaseDiagnose.getName(), list);
         }
     }
 
     public void allBaseRegulation() {
         List<BaseRegulationDTO> list = klRegulationBaseFacade.getSelectBase(new ArrayList<>());
         if (ListUtil.isNotEmpty(list)) {
-            redisTemplate.opsForValue().set(RedisEnum.allBaseRegulation.getName(), list);
+            redisUtil.set(RedisEnum.allBaseRegulation.getName(), list);
         }
     }
 }

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

@@ -37,6 +37,9 @@ public class OtherTipFacade {
         // 其他值提醒——输血
         otherTipProcess.processTransfusion(wordCrfDTO, res);
 
+        // 特殊规则——VTE结果
+        otherTipProcess.processSpecial(wordCrfDTO, res);
+
         // 结果去重处理
         commonFacade.dealMsg(res.getOtherList());
     }

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

@@ -13,6 +13,7 @@ import com.diagbot.exception.CommonErrorCode;
 import com.diagbot.exception.CommonException;
 import com.diagbot.model.entity.Diag;
 import com.diagbot.process.PushProcess;
+import com.diagbot.util.AgeUtil;
 import com.diagbot.util.CoreUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.ParamUtil;
@@ -101,7 +102,7 @@ public class PushFacade {
     public PushDTO processAggreate(PushVO pushVo) {
         // 年龄容错处理
         if (pushVo.getAgeNum() == null) {
-            pushVo.setAgeNum(CoreUtil.convertAge(pushVo.getAge()));
+            pushVo.setAgeNum(AgeUtil.convertAge(pushVo.getAge()));
         }
         PushDTO pushDTO = new PushDTO();
         pushDTO = this.pushFacIcss(pushVo);

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

@@ -4,6 +4,7 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.diagbot.client.StandConvertServiceClient;
 import com.diagbot.dto.StandConvertCrfDTO;
 import com.diagbot.dto.TermConceptDTO;
+import com.diagbot.entity.KlConcept;
 import com.diagbot.entity.KlLibraryInfo;
 import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.enums.LexiconEnum;

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

@@ -1,13 +1,13 @@
 package com.diagbot.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.GetAllForRelationDTO;
+import com.diagbot.dto.IndexBatchDTO;
 import com.diagbot.dto.IndexDTO;
 import com.diagbot.dto.KllisDetailDTO;
 import com.diagbot.dto.StaticKnowledgeIndexDTO;
 import com.diagbot.entity.KlConcept;
-import com.diagbot.vo.KllisDetailVO;
-import com.diagbot.vo.MedRetrievalVO;
-import com.diagbot.vo.StaticKnowledgeIndexVO;
+import com.diagbot.vo.*;
 
 import java.util.List;
 
@@ -23,7 +23,15 @@ public interface KlConceptMapper extends BaseMapper<KlConcept> {
 
     List<IndexDTO> index(MedRetrievalVO medRetrievalVO);
 
+    List<IndexBatchDTO> indexByApproval(IndexByApprovalVO indexByApprovalVO);
+
     List<StaticKnowledgeIndexDTO> staticIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO);
 
     List<KllisDetailDTO> getLisDetaisByNames(KllisDetailVO kllisDetailVO);
+
+    List<GetAllForRelationDTO> searchByTypeAndName(SearchConceptVO searchConceptVO);
+
+    List<GetAllForRelationDTO> searchByTypeAndNameAdd(SearchConceptVO searchConceptVO);
+
+    List<GetAllForRelationDTO> searchCollectionConcept(SearchCollectionConceptVO searchCollectionConceptVO);
 }

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

@@ -0,0 +1,16 @@
+package com.diagbot.mapper;
+
+import com.diagbot.entity.KlDiagnoseRecordDetail;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ * 诊断依据记录明细表 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+public interface KlDiagnoseRecordDetailMapper extends BaseMapper<KlDiagnoseRecordDetail> {
+
+}

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

@@ -0,0 +1,22 @@
+package com.diagbot.mapper;
+
+import com.diagbot.dto.DiagnoseRecordDTO;
+import com.diagbot.dto.ExportDiagnoseDTO;
+import com.diagbot.entity.KlDiagnoseRecord;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 诊断依据记录表 Mapper 接口
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+public interface KlDiagnoseRecordMapper extends BaseMapper<KlDiagnoseRecord> {
+
+    List<DiagnoseRecordDTO> getDiagnoseRecord();
+
+}

src/main/java/com/diagbot/model/ai/BeHospitalizedAI.java

@@ -242,7 +242,7 @@ public class BeHospitalizedAI extends ModelAI {
             try {
                 midData = loadAI(crfContent, crfServiceClient);
             } catch (Exception e) {
-                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "CRF模型【服务器】挂了!" + e.getMessage());
+                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "CRF解析文本【超时】或【服务出错】!");
             }
             /* 处理主诉 */
             if (StringUtil.isNotBlank(wordCrfDTO.getChiefLabel().getText())) {
@@ -683,7 +683,7 @@ public class BeHospitalizedAI extends ModelAI {
                     if (matcher.find()) {
                         String val = matcher.group();
                         vi.getPd().setValue(val);  // 重新赋值血压的数值
-                        vi.getPd().setUnit(bpName.substring(bpName.indexOf(val) + 1));   // 重新赋值血压的单位
+                        vi.getPd().setUnit(bpName.substring(bpName.indexOf(val) + val.length()));   // 重新赋值血压的单位
 
                         String[] bp = val.split("/");
 

src/main/java/com/diagbot/model/ai/process/EntityProcessLis.java

@@ -111,8 +111,10 @@ public class EntityProcessLis extends EntityProcess {
         if (value.trim().length() > 0) {
             val_unit = extract_digit_new(value);
         }
-        pd.setValue(val_unit[0]);
-        pd.setUnit(val_unit[1]);
+        if (val_unit != null && val_unit.length == 2) {
+            pd.setValue(val_unit[0]);
+            pd.setUnit(val_unit[1].trim()); // 单位去空格
+        }
         return pd;
     }
 

src/main/java/com/diagbot/model/ai/process/EntityProcessPacs.java

@@ -6,9 +6,12 @@ import com.diagbot.model.ai.model.EntityEnum;
 import com.diagbot.model.ai.model.Lemma;
 import com.diagbot.model.entity.BodyPart;
 import com.diagbot.model.entity.Modification;
+import com.diagbot.model.entity.PD;
 import com.diagbot.model.entity.Pacs;
+import com.diagbot.model.entity.PacsNum;
 import com.diagbot.model.label.PacsLabel;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.StringUtil;
 import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
@@ -69,8 +72,6 @@ public class EntityProcessPacs extends EntityProcess {
         }
         pacsLabel.setPacsResults(pacsResults);
 
-
-
         // 辅检诊断
         List<Lemma> pacsDisease = createEntityTree(aiOut, EntityEnum.DIEASE.toString());
         List<Pacs> disList = new ArrayList<>();
@@ -81,5 +82,31 @@ public class EntityProcessPacs extends EntityProcess {
             disList.add(dis);
         }
         pacsLabel.setDisease(disList);
+
+        // 辅检结果添加数值型结构
+        List<PacsNum> pacsNumList = Lists.newArrayList();
+        List<Lemma> vitalLemmas = createEntityTree(aiOut, EntityEnum.SIGN.toString()); // 辅检中的体征结果
+        for (Lemma lemma : vitalLemmas) {
+            if (lemma.isHaveChildren()) {
+                for (Lemma relationLemma : lemma.getRelationLemmas()) {
+                    if (relationLemma.getProperty().equals(EntityEnum.INDEX_VALUE.toString())) { // 体征结果
+                        String value = relationLemma.getText();
+                        if (StringUtil.isNotBlank(value)) {
+                            PacsNum pacsNum = new PacsNum();
+                            pacsNum.setName(lemma.getText());
+                            pacsNum.setStandName(lemma.getText());
+                            PD pd = new PD();
+                            String[] val_unit = new String[2];
+                            val_unit = extract_digit_new(value);
+                            pd.setValue(val_unit[0]);
+                            pd.setUnit(val_unit[1]);
+                            pacsNum.setPd(pd);
+                            pacsNumList.add(pacsNum);
+                        }
+                    }
+                }
+            }
+            pacsLabel.setPacsNumList(pacsNumList);
+        }
     }
 }

src/main/java/com/diagbot/model/entity/PacsNum.java

@@ -0,0 +1,13 @@
+package com.diagbot.model.entity;
+
+import lombok.Data;
+
+/**
+ * @description: 辅检数值型
+ * @author: zhoutg
+ * @date: 2021/9/15 9:31
+ */
+@Data
+public class PacsNum extends General{
+    private PD pd;
+}

src/main/java/com/diagbot/model/label/PacsLabel.java

@@ -3,6 +3,7 @@ package com.diagbot.model.label;
 
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.model.entity.Pacs;
+import com.diagbot.model.entity.PacsNum;
 import lombok.Getter;
 import lombok.Setter;
 
@@ -24,4 +25,5 @@ public class PacsLabel extends GeneralLabel {
     private List<Pacs> disease = new ArrayList<>(); // 辅检提取的诊断
     private List<Item> res = new ArrayList<>(); // 描述文本 + 诊断
     private List<Item> item = new ArrayList<>(); // 所有的辅检项目
+    private List<PacsNum> pacsNumList = new ArrayList<>(); // 辅检所有的数值项目
 }

src/main/java/com/diagbot/process/BillProcess.java

@@ -118,7 +118,8 @@ public class BillProcess {
                                         commonRule.compareItemWithBill(diags, ruleBaseDTO, billMsgList, ConEnum.disease.getName(), ruleSimpleDTO);
                                         break;
                                     case LisName: // 化验开单互斥
-                                        commonRule.exclusionBill(wordCrfDTO.getLisOrder(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
+                                        commonRule.exclusionBillOrder(wordCrfDTO.getLisOrder(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
+                                        commonRule.exclusionBillStruct(wordCrfDTO.getLis(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
                                         break;
                                     case LisSubName: // 化验结果
                                         lisRule.bill(wordCrfDTO.getLis(), ruleBaseDTO, billMsgList, ConEnum.lis.getName(), ruleSimpleDTO);
@@ -131,7 +132,8 @@ public class BillProcess {
                                     case PacsSubName: // 辅助检查子项目
                                         if (ruleBaseDTO.getBaseType() != null && ruleBaseDTO.getBaseType().equals(BaseTypeEnum.B5.getKey())) {
                                             // 开单项互斥
-                                            commonRule.exclusionBill(wordCrfDTO.getPacsOrder(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
+                                            commonRule.exclusionBillOrder(wordCrfDTO.getPacsOrder(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
+                                            commonRule.exclusionBillStruct(wordCrfDTO.getPacs(), ruleBaseDTO, billMsgList, ConEnum.exclusion.getName(), ruleSimpleDTO, set);
                                         } else {
                                             // 辅检项目,暂无数据
                                             pacsRule.bill(wordCrfDTO.getPacs(), ruleBaseDTO, billMsgList, ConEnum.pacs.getName(), ruleSimpleDTO);

src/main/java/com/diagbot/process/OtherTipProcess.java

@@ -2,6 +2,7 @@ package com.diagbot.process;
 
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
+import com.diagbot.biz.push.entity.Scale;
 import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.IndicationDTO;
 import com.diagbot.dto.RuleBaseDTO;
@@ -9,19 +10,30 @@ import com.diagbot.dto.RuleConditionDTO;
 import com.diagbot.dto.RuleExtDTO;
 import com.diagbot.dto.WordCrfDTO;
 import com.diagbot.enums.LexiconEnum;
+import com.diagbot.enums.RedisEnum;
 import com.diagbot.enums.RuleTypeEnum;
 import com.diagbot.enums.TypeEnum;
 import com.diagbot.facade.CommonFacade;
+import com.diagbot.model.entity.PD;
+import com.diagbot.model.entity.PacsNum;
 import com.diagbot.model.label.PacsLabel;
+import com.diagbot.rule.AgeRule;
 import com.diagbot.rule.CommonRule;
 import com.diagbot.rule.GroupRule;
 import com.diagbot.rule.LisRule;
 import com.diagbot.rule.PacsRule;
+import com.diagbot.util.CoreUtil;
+import com.diagbot.util.DateUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.MsgUtil;
+import com.diagbot.util.RedisUtil;
+import com.diagbot.util.ReflectUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.vo.RuleVO;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
+import java.util.Date;
 import java.util.List;
 
 /**
@@ -42,6 +54,10 @@ public class OtherTipProcess {
     LisRule lisRule;
     @Autowired
     PacsRule pacsRule;
+    @Autowired
+    RedisUtil redisUtil;
+    @Autowired
+    AgeRule ageRule;
 
     /**
      * 处理业务——化验
@@ -64,7 +80,7 @@ public class OtherTipProcess {
                 for (RuleConditionDTO ruleConditionDTO : ruleConditionDTOList) {
                     List<RuleBaseDTO> ruleBaseDTOList = ruleConditionDTO.getRuleBaseDTOList();
                     // 2、规则匹配
-                    lisRule.otherLis(lis, ruleBaseDTOList, otherList, wordCrfDTO);
+                    lisRule.otherLis(lis, ruleBaseDTOList, otherList, wordCrfDTO, ruleConditionDTO.getMsg());
                 }
             }
         }
@@ -96,6 +112,72 @@ public class OtherTipProcess {
                 }
             }
         }
+
+        // TODO 后期删除 辅检数值型匹配
+        List<PacsNum> pacsNumList = pacsLabel.getPacsNumList();
+        for (PacsNum pacsNum : pacsNumList) {
+            if ("心率".equals(pacsNum.getStandName())) {
+                PD pd = pacsNum.getPd();
+                if (pd != null && StringUtil.isNotBlank(pd.getValue())) {
+                    double v = Double.parseDouble(pd.getValue());
+                    String content = pacsNum.getStandName() + pd.getValue() + pd.getUnit();
+                    Double ageNum = wordCrfDTO.getAgeNum();
+                    Double min = null, max = null;
+                    String suggest = "";
+                    if (ageNum < 0.019) {
+                        min = 110D;
+                        max = 170D;
+                        suggest = "年龄0-6天心率正常值为110-170bpm";
+                    } else if (ageNum < 0.164) {
+                        min = 90D;
+                        max = 160D;
+                        suggest = "年龄7-59天心率正常值为90-160bpm";
+                    } else if (ageNum < 2) {
+                        min = 90D;
+                        max = 150D;
+                        suggest = "年龄2-23月心率正常值为90-150bpm";
+                    } else if (ageNum < 3) {
+                        min = 80D;
+                        max = 140D;
+                        suggest = "年龄2-3岁心率正常值为80-140bpm";
+                    } else if (ageNum < 6) {
+                        min = 80D;
+                        max = 130D;
+                        suggest = "年龄3-5岁心率正常值为80-130bpm";
+                    } else if (ageNum < 11) {
+                        min = 70D;
+                        max = 120D;
+                        suggest = "年龄6-10岁心率正常值为70-120bpm";
+                    } else if (ageNum < 18) {
+                        min = 60D;
+                        max = 120D;
+                        suggest = "年龄11-17岁心率正常值为60-120bpm";
+                    } else if (ageNum <= 150) {
+                        min = 60D;
+                        max = 110D;
+                        suggest = "年龄18-150岁心率正常值为60-110bpm";
+                    }
+                    int flag = compareValue(min, max, v);
+                    if (flag == 0) {
+                        String msg = String.format("该患者%s，%s", content, suggest);
+                        BillMsg billMsg = new BillMsg();
+                        billMsg.setMsg(msg);
+                        billMsg.setContent(content);
+                        otherList.add(billMsg);
+                    }
+                }
+            }
+        }
+    }
+
+    public int compareValue(Double min, Double max, Double v) {
+        if (min == null || max == null || v == null) {
+            return -1;
+        }
+        if (v >= min && v <= max) {
+            return 1;
+        }
+        return 0;
     }
 
     /**
@@ -125,6 +207,93 @@ public class OtherTipProcess {
         }
     }
 
+    /**
+     * 处理业务——特殊规则
+     *
+     * @param wordCrfDTO
+     * @param res
+     */
+    public void processSpecial(WordCrfDTO wordCrfDTO, IndicationDTO res) {
+        List<BillMsg> otherList = res.getOtherList();
+        // 判断VTE评估结果和出血风险结果
+        List<Scale> scaleList = wordCrfDTO.getScale();
+        // VTE评估结果
+        String vteResult = "";
+        // VTE出血风险
+        String vteBlood = "";
+        if (ListUtil.isNotEmpty(scaleList)) {
+            for (Scale scale : scaleList) {
+                String result = scale.getResult();
+                if (StringUtil.isNotBlank(result)) {
+                    if (result.matches("高危|中危|极高危")) {
+                        vteResult = result;
+                    } else if (result.matches("有|无")) {
+                        vteBlood = result;
+                    }
+                }
+            }
+        }
+
+        // VTE评估结果 和 VTE出血风险都有值
+        if (StringUtil.isNotBlank(vteResult) && StringUtil.isNotBlank(vteBlood)) {
+            // 是否有药物医嘱
+            Boolean drugAdviceFlag = false;
+            // 是否有机械医嘱
+            Boolean mechanicalAdviceFlag = false;
+            // 获取药品医嘱
+            List<String> drugAdviceList = redisUtil.get(RedisEnum.vteAdvice.getName() + "药物医嘱");
+            drugAdviceFlag = hasAdvice(wordCrfDTO.getDrug(), drugAdviceList);
+            if (!drugAdviceFlag) {
+                // 获取机械医嘱
+                List<String> mechanicalAdviceList = redisUtil.get(RedisEnum.vteAdvice.getName() + "机械医嘱");
+                mechanicalAdviceFlag = hasAdvice(wordCrfDTO.getOtherAdvice(), mechanicalAdviceList);
+            }
+            // 无药物医嘱且无机械医嘱，拼接提示语
+            if (!drugAdviceFlag && !mechanicalAdviceFlag) {
+                String msg = "该患者VTE评估为%s，伴有出血风险，建议开机械预防医嘱";
+                if (vteBlood.matches("无")) {
+                    msg = "该患者VTE评估为%s，无出血风险，建议开药物或机械预防医嘱";
+                }
+                msg = String.format(msg, vteResult);
+                BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.other.getName(), msg, null, null, null);
+                CoreUtil.addBeanToList(otherList, billMsg);
+            }
+        }
+    }
+
+    /**
+     * 是否有效医嘱(6天)
+     *
+     * @param tList
+     * @param nameList
+     * @param <T>
+     * @return
+     */
+    public <T> Boolean hasAdvice(List<T> tList, List<String> nameList) {
+        Boolean hasAdviceFlag = false;
+        if (ListUtil.isEmpty(tList) || ListUtil.isEmpty(nameList)) {
+            return hasAdviceFlag;
+        }
+        for (T item : tList) {
+            String name = ReflectUtil.getProperty(item, "name");
+            if (StringUtil.isNotBlank(name)) {
+                if (nameList.contains(name)) {
+                    // 开单时间
+                    String dateValue = ReflectUtil.getProperty(item, "dateValue");
+                    // 当前时间
+                    String curDate = DateUtil.formatDateTime(new Date());
+                    // 6天有效医嘱
+                    int flag = CoreUtil.compareTime(dateValue, curDate, 60L * 24 * 6, true, false);
+                    if (flag == 1) {
+                        hasAdviceFlag = true;
+                        break;
+                    }
+                }
+            }
+        }
+        return hasAdviceFlag;
+    }
+
     /**
      * 获取其他值提醒入参——辅检
      *

src/main/java/com/diagbot/rule/CommonRule.java

@@ -5,10 +5,12 @@ import com.diagbot.biz.push.entity.Pacs;
 import com.diagbot.dto.BaseDiagnoseDTO;
 import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.DictionaryInfoDTO;
+import com.diagbot.dto.MatchDTO;
 import com.diagbot.dto.RuleBaseDTO;
 import com.diagbot.dto.RuleSimpleDTO;
 import com.diagbot.dto.WordCrfDTO;
 import com.diagbot.enums.BaseDiagnoseTypeEnum;
+import com.diagbot.enums.CommonEnum;
 import com.diagbot.enums.ConEnum;
 import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RedisEnum;
@@ -18,7 +20,6 @@ import com.diagbot.facade.KlDictionaryInfoFacade;
 import com.diagbot.model.entity.Clinical;
 import com.diagbot.model.entity.Negative;
 import com.diagbot.util.BeanUtil;
-import com.diagbot.util.CatalogueUtil;
 import com.diagbot.util.CoreUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
@@ -28,6 +29,7 @@ import com.diagbot.util.RedisUtil;
 import com.diagbot.util.ReflectUtil;
 import com.diagbot.util.RegexUtil;
 import com.diagbot.util.StringUtil;
+import com.google.common.collect.Lists;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
@@ -35,7 +37,6 @@ import org.springframework.stereotype.Component;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.Date;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -250,12 +251,15 @@ public class CommonRule {
         if (ListUtil.isNotEmpty(pacsList)) {
             sortByProperty(pacsList, "dateValue");
             Pacs pacs = pacsList.get(pacsList.size() - 1); // 按时间排序，取最后一条
+            if (StringUtil.isNotBlank(pacs.getName())) {
+                ruleSimpleDTO.setStructName(pacs.getName());
+            }
             String result = pacs.getResult();
             if (StringUtil.isNotBlank(result) && StringUtil.isNotBlank(ruleBaseDTO.getBaseEqValue())
                     && RegexUtil.getRegexRes(result, ruleBaseDTO.getBaseEqValue())) {
                 String dateValue = pacs.getDateValue(); // 结果日期
                 String orderDateValue = ruleSimpleDTO.getDateValue(); // 开单项日期
-                int flag = CoreUtil.compareTime(dateValue, orderDateValue, 60L * 24 * 7, false);
+                int flag = CoreUtil.compareTime(dateValue, orderDateValue, 60L * 24 * 7, false, false);
                 if (flag == 1) {
                     ruleSimpleDTO.setContent(result);
                     ruleSimpleDTO.setConType(conType);
@@ -281,13 +285,13 @@ public class CommonRule {
         if (ListUtil.isNotEmpty(lisList)) {
             sortByProperty(lisList, "dateValue");
             Lis lis = lisList.get(lisList.size() - 1); // 按时间排序，取最后一条
-            Map<String, Object> lisMap = CoreUtil.compareLis(ruleBaseDTO, lis);
-            if (CoreUtil.getMapFlag(lisMap)) {
+            MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lis);
+            if (matchDTO != null) {
                 String dateValue = lis.getDateValue(); // 结果日期
                 String orderDateValue = ruleSimpleDTO.getDateValue(); // 开单项日期
-                int flag = CoreUtil.compareTime(dateValue, orderDateValue, 60L * 24 * 7, false);
+                int flag = CoreUtil.compareTime(dateValue, orderDateValue, 60L * 24 * 7, false, false);
                 if (flag == 1) { // 有效期范围内
-                    ruleSimpleDTO.setContent(CoreUtil.getMapMsg(lisMap));
+                    ruleSimpleDTO.setContent(matchDTO.getContent());
                     ruleSimpleDTO.setConType(conType);
                     BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
                     CoreUtil.addBeanToList(billMsgList, billMsg);
@@ -345,76 +349,103 @@ public class CommonRule {
      * @param billMsgList
      */
     public void repeat24Bill(WordCrfDTO wordCrfDTO, List<BillMsg> billMsgList) {
-        repeat24BillWithType(billMsgList, wordCrfDTO.getLisOrder(), TypeEnum.lis.getName(), ConEnum.repeat24.getName()); // 化验重复开单
-        repeat24BillWithType(billMsgList, wordCrfDTO.getPacsOrder(), TypeEnum.pacs.getName(), ConEnum.repeat24.getName()); // 辅检重复开单
+        // 当前开单项与当前开单项重复开立
+        repeat24BillWithOrder(billMsgList, wordCrfDTO.getLisOrder(), TypeEnum.lis.getName(), ConEnum.repeat24.getName()); // 化验重复开单
+        repeat24BillWithOrder(billMsgList, wordCrfDTO.getPacsOrder(), TypeEnum.pacs.getName(), ConEnum.repeat24.getName()); // 辅检重复开单
         // repeat24BillWithType(billMsgList, wordCrfDTO.getDrugOrder(), TypeEnum.drug.getName(), ConEnum.repeat24.getName()); // 药品重复开单
         // repeat24BillWithType(billMsgList, wordCrfDTO.getOperationOrder(), TypeEnum.operation.getName(), ConEnum.repeat24.getName()); // 手术重复开单
         // repeat24BillWithType(billMsgList, wordCrfDTO.getTransfusionOrder(), TypeEnum.transfusion.getName(), ConEnum.repeat24.getName()); // 输血重复开单
-    }
 
-    // /**
-    //  * 互斥开单项——辅检
-    //  *
-    //  * @param wordCrfDTO
-    //  * @param ruleBaseDTO
-    //  * @param billMsgList
-    //  * @param ruleSimpleDTO
-    //  * @param set           用于记录：A与B不宜同时进行, B与A不宜同时进行 只能提示一个
-    //  */
-    // public void exclusionBill(WordCrfDTO wordCrfDTO, RuleBaseDTO ruleBaseDTO, List<BillMsg> billMsgList, String conType, RuleSimpleDTO ruleSimpleDTO, Set<String> set) {
-    //     // 辅检开单项互斥
-    //     List<Pacs> pacsOrder = wordCrfDTO.getPacsOrder();
-    //     if (ListUtil.isNotEmpty(pacsOrder) && pacsOrder.size() > 1) {
-    //         // 不同的辅检项目可能对应同一个uniqueName，提示显示多条
-    //         Map<String, List<Pacs>> map = EntityUtil.makeEntityListMap(pacsOrder, "uniqueName");
-    //         List<Pacs> orginNameList = map.get(ruleBaseDTO.getBaseLibName()); // 互斥名称
-    //         if (map.get(ruleBaseDTO.getBaseLibName()) != null) {
-    //             for (Pacs pacs : orginNameList) {
-    //                 String orginName = pacs.getName();
-    //                 // A与B不宜同时进行, B与A不宜同时进行 只能提示一个
-    //                 if (!set.contains(ruleSimpleDTO.getLibName() + "******" + orginName)) {
-    //                     set.add(ruleSimpleDTO.getLibName() + "******" + orginName);
-    //                     set.add(orginName + "******" + ruleSimpleDTO.getLibName());
-    //                     ruleSimpleDTO.setContent(orginName);
-    //                     ruleSimpleDTO.setConType(conType);
-    //                     BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
-    //                     CoreUtil.addBeanToList(billMsgList, billMsg);
-    //                 }
-    //             }
-    //         }
-    //     }
-    // }
+        // 当前开单项和结构化开单项重复开立
+        repeat24BillWithStruct(billMsgList, wordCrfDTO.getLisOrder(), wordCrfDTO.getLis(), TypeEnum.lis.getName(), ConEnum.repeat24.getName()); // 化验重复开单
+        repeat24BillWithStruct(billMsgList, wordCrfDTO.getPacsOrder(), wordCrfDTO.getPacs(), TypeEnum.pacs.getName(), ConEnum.repeat24.getName()); // 辅检重复开单
+    }
 
     /**
-     * 互斥开单项
+     * 互斥开单项（结构化）
      *
-     * @param orderList      开单列表
+     * @param orderList     开单列表
      * @param ruleBaseDTO
      * @param billMsgList
      * @param ruleSimpleDTO
      * @param set           用于记录：A与B不宜同时进行, B与A不宜同时进行 只能提示一个
      */
-    public <T> void exclusionBill(List<T> orderList, RuleBaseDTO ruleBaseDTO, List<BillMsg> billMsgList, String conType, RuleSimpleDTO ruleSimpleDTO, Set<String> set) {
+    public <T> void exclusionBillOrder(List<T> orderList, RuleBaseDTO ruleBaseDTO, List<BillMsg> billMsgList, String conType, RuleSimpleDTO ruleSimpleDTO, Set<String> set) {
         if (ListUtil.isNotEmpty(orderList) && orderList.size() > 1) {
+            String baseLibName = ruleBaseDTO.getBaseLibName(); // 互斥名称
+            String libName = ruleSimpleDTO.getLibName(); // 标准名称
+            String inputName = ruleSimpleDTO.getInputName(); // 医院名称
+            // 加入集合后，会出现自己与自己互斥的数据，这些数据不提示
+            if (libName.equals(baseLibName)) {
+                return;
+            }
+            // 不同的项目可能对应同一个uniqueName，提示显示多条
+            Map<String, List<T>> map = EntityUtil.makeEntityListMap(orderList, "uniqueName");
+            List<T> orginNameList = map.get(baseLibName);
+            if (map.get(ruleBaseDTO.getBaseLibName()) != null) {
+                for (T bean : orginNameList) {
+                    String orginName = ReflectUtil.getProperty(bean, "name");
+                    // A与B不宜同时进行, B与A不宜同时进行，只能提示一个
+                    if (!set.contains(inputName + CommonEnum.splitSymbol.getName() + orginName)) {
+                        set.add(inputName + CommonEnum.splitSymbol.getName() + orginName);
+                        set.add(orginName + CommonEnum.splitSymbol.getName() + inputName);
+                        ruleSimpleDTO.setContent(orginName);
+                        ruleSimpleDTO.setConType(conType);
+                        BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
+                        CoreUtil.addBeanToList(billMsgList, billMsg);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 互斥开单项（结构化）
+     *
+     * @param orderList     开单列表
+     * @param ruleBaseDTO
+     * @param billMsgList
+     * @param ruleSimpleDTO
+     * @param set           用于记录：A与B不宜同时进行, B与A不宜同时进行 只能提示一个
+     */
+    public <T> void exclusionBillStruct(List<T> orderList, RuleBaseDTO ruleBaseDTO, List<BillMsg> billMsgList, String conType, RuleSimpleDTO ruleSimpleDTO, Set<String> set) {
+        if (ListUtil.isNotEmpty(orderList)) {
+            String baseLibName = ruleBaseDTO.getBaseLibName(); // 互斥名称
+            String libName = ruleSimpleDTO.getLibName(); // 标准名称
+            // 加入集合后，会出现自己与自己互斥的数据，这些数据不提示
+            if (libName.equals(baseLibName)) {
+                return;
+            }
             // 不同的项目可能对应同一个uniqueName，提示显示多条
             Map<String, List<T>> map = EntityUtil.makeEntityListMap(orderList, "uniqueName");
             List<T> orginNameList = map.get(ruleBaseDTO.getBaseLibName());
             if (map.get(ruleBaseDTO.getBaseLibName()) != null) {
                 for (T bean : orginNameList) {
-                    String orderDateValue = ReflectUtil.getProperty(ruleSimpleDTO, "dateValue");
-                    String beanDateValue = ReflectUtil.getProperty(bean, "dateValue");
-                    int dateFlag = CoreUtil.compareTime(beanDateValue, orderDateValue);
-                    if (dateFlag == 1) {
-                        String orginName = ReflectUtil.getProperty(bean, "name");
-                        // A与B不宜同时进行, B与A不宜同时进行 只能提示一个
-                        // if (!set.contains(ruleSimpleDTO.getLibName() + "******" + orginName)) {
-                        //     set.add(ruleSimpleDTO.getLibName() + "******" + orginName);
-                        //     set.add(orginName + "******" + ruleSimpleDTO.getLibName());
-                            ruleSimpleDTO.setContent(orginName);
-                            ruleSimpleDTO.setConType(conType);
-                            BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
-                            CoreUtil.addBeanToList(billMsgList, billMsg);
-                        // }
+                    // 化验明细项不为空的数据，说明是细项，舍弃
+                    if (TypeEnum.lis.getName().equals(ruleSimpleDTO.getLibTypeName())) {
+                        String detailName = ReflectUtil.getProperty(bean, "detailName");
+                        if (StringUtil.isNotBlank(detailName)) {
+                            continue;
+                        }
+                    }
+                    String finishDateValue = ReflectUtil.getProperty(bean, "finishDateValue");
+                    // 报告时间为空，再比较时间间隔
+                    if (StringUtil.isBlank(finishDateValue)) {
+                        String orderDateValue = ReflectUtil.getProperty(ruleSimpleDTO, "dateValue");
+                        String beanDateValue = ReflectUtil.getProperty(bean, "dateValue");
+                        int dateFlag = CoreUtil.compareTime(beanDateValue, orderDateValue, 60L * 24, false, false);
+                        if (dateFlag == 1) {
+                            String orginName = ReflectUtil.getProperty(bean, "name");
+                            // A与B不宜同时进行, B与A不宜同时进行，只能提示一个
+                            if (!set.contains(libName + CommonEnum.splitSymbol.getName() + orginName)) {
+                                set.add(libName + CommonEnum.splitSymbol.getName() + orginName);
+                                set.add(orginName + CommonEnum.splitSymbol.getName() + libName);
+                                ruleSimpleDTO.setContent(orginName);
+                                ruleSimpleDTO.setConType(conType);
+                                BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
+                                CoreUtil.addBeanToList(billMsgList, billMsg);
+                            }
+                        }
                     }
                 }
             }
@@ -441,7 +472,7 @@ public class CommonRule {
     }
 
     /**
-     * 24小时重复开单入口
+     * 24小时重复开单入口——与开单项比较
      *
      * @param billMsgList
      * @param itemList
@@ -449,10 +480,11 @@ public class CommonRule {
      * @param conType     禁忌条件
      * @param <T>
      */
-    public <T> void repeat24BillWithType(List<BillMsg> billMsgList, List<T> itemList, String type, String conType) {
+    public <T> void repeat24BillWithOrder(List<BillMsg> billMsgList, List<T> itemList, String type, String conType) {
         if (ListUtil.isEmpty(itemList)) {
             return;
         }
+        // name+uniqueName 作为key（备注：标准名称相同，医院名称不同，认为是不同的开单项）
         Map<String, List<T>> map = CoreUtil.makeEntityListMap(itemList, "name", "uniqueName");
         for (String key : map.keySet()) {
             List<T> items = map.get(key);
@@ -462,23 +494,17 @@ public class CommonRule {
                     T it = items.get(i);
                     String curDateValue = ReflectUtil.getProperty(it, "dateValue");
                     if (StringUtil.isNotBlank(curDateValue)) {
-                        Date curDate = CatalogueUtil.parseStringDate(curDateValue);
                         for (int j = i + 1; j < items.size(); j++) {
                             T itNext = items.get(j);
                             String nextDateValue = ReflectUtil.getProperty(itNext, "dateValue");
                             if (StringUtil.isNotBlank(nextDateValue)) {
-                                Date nextDate = CatalogueUtil.parseStringDate(nextDateValue);
-                                if (!CatalogueUtil.compareTime(curDate, nextDate, 60L * 24, true)
+                                int dateFlag = CoreUtil.compareTime(curDateValue, nextDateValue, 60L * 24, false, true);
+                                if (dateFlag == 1
                                         && getFrquenceType(ReflectUtil.getProperty(it, "frequency"))
                                         .equals(getFrquenceType(ReflectUtil.getProperty(itNext, "frequency")))) {
                                     String name = (String) CoreUtil.getFieldValue(it, "name");
                                     String uniqueName = (String) CoreUtil.getFieldValue(it, "uniqueName");
-                                    RuleSimpleDTO ruleSimpleDTO = new RuleSimpleDTO();
-                                    ruleSimpleDTO.setInputName(name);
-                                    ruleSimpleDTO.setLibName(uniqueName);
-                                    ruleSimpleDTO.setLibTypeName(type);
-                                    ruleSimpleDTO.setContent(name);
-                                    ruleSimpleDTO.setConType(ConEnum.repeat24.getName());
+                                    RuleSimpleDTO ruleSimpleDTO = new RuleSimpleDTO(name, uniqueName, type, name, conType);
                                     BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
                                     CoreUtil.addBeanToList(billMsgList, billMsg);
                                     break;
@@ -491,6 +517,56 @@ public class CommonRule {
         }
     }
 
+    /**
+     * 24小时重复开单——与结构化比较
+     *
+     * @param billMsgList
+     * @param orderList
+     * @param itemList
+     * @param type
+     * @param conType
+     * @param <T>
+     */
+    public <T> void repeat24BillWithStruct(List<BillMsg> billMsgList, List<T> orderList, List<T> itemList, String type, String conType) {
+        if (ListUtil.isEmpty(itemList) || ListUtil.isEmpty(orderList)) {
+            return;
+        }
+        // name+uniqueName 作为key（备注：标准名称相同，医院名称不同，认为是不同的开单项）
+        Map<String, List<T>> map = CoreUtil.makeEntityListMap(itemList, "name", "uniqueName");
+        for (T order : orderList) {
+            String orderName = ReflectUtil.getProperty(order, "name");
+            String orderUniqueName = ReflectUtil.getProperty(order, "uniqueName");
+            List<T> items = map.get(orderName + CommonEnum.splitSymbol.getName() + orderUniqueName);
+            if (ListUtil.isNotEmpty(items)) {
+                for (T it : items) {
+                    // 化验明细项不为空的数据，说明是细项，舍弃
+                    if (TypeEnum.lis.getName().equals(type)) {
+                        String detailName = ReflectUtil.getProperty(order, "detailName");
+                        if (StringUtil.isNotBlank(detailName)) {
+                            continue;
+                        }
+                    }
+                    String finishDateValue = ReflectUtil.getProperty(it, "finishDateValue");
+                    // 报告时间为空，再比较时间间隔
+                    if (StringUtil.isBlank(finishDateValue)) {
+                        String curDateValue = ReflectUtil.getProperty(order, "dateValue"); // 当前开单时间
+                        String pastDateValue = ReflectUtil.getProperty(it, "dateValue"); // 历史开单时间
+                        int dateFlag = CoreUtil.compareTime(pastDateValue, curDateValue, 60L * 24, false, false);
+                        // 规定时间内，并且频次相同
+                        if (dateFlag == 1 &&
+                                getFrquenceType(ReflectUtil.getProperty(it, "frequency"))
+                                        .equals(getFrquenceType(ReflectUtil.getProperty(it, "frequency")))) {
+                            RuleSimpleDTO ruleSimpleDTO = new RuleSimpleDTO(orderName, orderUniqueName, type, orderName, conType);
+                            BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
+                            CoreUtil.addBeanToList(billMsgList, billMsg);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * 高风险药品、手术
      *
@@ -581,7 +657,14 @@ public class CommonRule {
     }
 
     public static void main(String[] args) {
-        CommonRule commonRule = new CommonRule();
-        System.out.println(commonRule.getFrquenceType(null));
+        List<Lis> lisList = Lists.newArrayList();
+        Lis lis = new Lis();
+        lis.setName("血常规");
+        lis.setUniqueName(null);
+        lisList.add(lis);
+        Map<String, List<Lis>> map = lisList.stream().collect(Collectors.groupingBy(r -> {
+            return "333";
+        }));
+        System.out.println(map);
     }
 }

src/main/java/com/diagbot/rule/GroupRule.java

@@ -6,9 +6,11 @@ import com.diagbot.dto.RuleBaseDTO;
 import com.diagbot.dto.RuleSimpleDTO;
 import com.diagbot.dto.WordCrfDTO;
 import com.diagbot.util.CoreUtil;
+import com.diagbot.util.ListUtil;
 import com.diagbot.util.MsgNewUtil;
 import com.diagbot.util.RegexUtil;
 import com.diagbot.util.StringUtil;
+import com.google.common.collect.Lists;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -80,9 +82,11 @@ public class GroupRule {
         String menstrual = wordCrfDTO.getMenstrual(); // 月经史
         String marriage = wordCrfDTO.getMarriage(); // 婚姻
         String marital = wordCrfDTO.getMarital();// 婚育史
+        String pasts = wordCrfDTO.getPasts(); // 既往史
         boolean flag = false;
         String regex = "";
         String regex2 = "";
+        List<String> groupList = Lists.newArrayList(); // 分组信息
         List<String> nameList = CoreUtil.getSplit(ruleBaseDTO.getBaseLibName());
         for (String name : nameList) {
             switch (name) {
@@ -135,23 +139,39 @@ public class GroupRule {
                         flag = true;
                     }
                     break;
-                case "未经产妇":
+                case "未经产妇": // 女性+（婚育史或既往史)数值累加为0
                     regex = "(\\d+)-(\\d+)-(\\d+)-(\\d+)";
-                    if (sex == 2 && StringUtil.isNotBlank(marital) && RegexUtil.getRegexRes(marital, regex)) {
-                        if (Integer.parseInt(RegexUtil.getRegexData(marital, regex, 1))
-                                + Integer.parseInt(RegexUtil.getRegexData(marital, regex, 2))
-                                + Integer.parseInt(RegexUtil.getRegexData(marital, regex, 3)) == 0) {
-                            flag = true;
+                    if (sex == 2) {
+                        if (StringUtil.isNotBlank(marital) && RegexUtil.getRegexRes(marital, regex)) {
+                            // 婚育史判断
+                            groupList = RegexUtil.getRegexDataList(marital, regex);
+                        } else if (StringUtil.isNotBlank(pasts) && RegexUtil.getRegexRes(pasts, regex)) {
+                            // 既往史判断
+                            groupList = RegexUtil.getRegexDataList(pasts, regex);
+                        }
+                        if (ListUtil.isNotEmpty(groupList) && groupList.size() == 4) {
+                            if (Integer.parseInt(groupList.get(0)) + Integer.parseInt(groupList.get(1))
+                                    + Integer.parseInt(groupList.get(2)) == 0) {
+                                flag = true;
+                            }
                         }
                     }
                     break;
-                case "经产妇":
+                case "经产妇": // 女性+（婚育史或既往史)数值累加>=1
                     regex = "(\\d+)-(\\d+)-(\\d+)-(\\d+)";
-                    if (sex == 2 && StringUtil.isNotBlank(marital) && RegexUtil.getRegexRes(marital, regex)) {
-                        if (Integer.parseInt(RegexUtil.getRegexData(marital, regex, 1))
-                                + Integer.parseInt(RegexUtil.getRegexData(marital, regex, 2))
-                                + Integer.parseInt(RegexUtil.getRegexData(marital, regex, 3)) >= 1) {
-                            flag = true;
+                    if (sex == 2) {
+                        if (StringUtil.isNotBlank(marital) && RegexUtil.getRegexRes(marital, regex)) {
+                            // 婚育史判断
+                            groupList = RegexUtil.getRegexDataList(marital, regex);
+                        } else if (StringUtil.isNotBlank(pasts) && RegexUtil.getRegexRes(pasts, regex)) {
+                            // 既往史判断
+                            groupList = RegexUtil.getRegexDataList(pasts, regex);
+                        }
+                        if (ListUtil.isNotEmpty(groupList) && groupList.size() == 4) {
+                            if (Integer.parseInt(groupList.get(0)) + Integer.parseInt(groupList.get(1))
+                                    + Integer.parseInt(groupList.get(2)) >= 1) {
+                                flag = true;
+                            }
                         }
                     }
                     break;

src/main/java/com/diagbot/rule/LisRule.java

@@ -3,6 +3,7 @@ package com.diagbot.rule;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.LisOtherDTO;
+import com.diagbot.dto.MatchDTO;
 import com.diagbot.dto.RuleBaseDTO;
 import com.diagbot.dto.RuleSimpleDTO;
 import com.diagbot.dto.WordCrfDTO;
@@ -18,6 +19,7 @@ import org.springframework.stereotype.Component;
 
 import java.util.List;
 import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * @description: 化验规则
@@ -46,9 +48,9 @@ public class LisRule {
     public void bill(List<Lis> inputLis, RuleBaseDTO ruleBaseDTO, List<BillMsg> billMsgList, String conType, RuleSimpleDTO ruleSimpleDTO) {
         if (ListUtil.isNotEmpty(inputLis) && StringUtil.isNotBlank(ruleBaseDTO.getBaseLibName())) {
             for (Lis lis : inputLis) {
-                Map<String, Object> map = CoreUtil.compareLis(ruleBaseDTO, lis);
-                if (CoreUtil.getMapFlag(map)) {
-                    ruleSimpleDTO.setContent((String) map.get("msg"));
+                MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lis);
+                if (matchDTO != null) {
+                    ruleSimpleDTO.setContent(matchDTO.getContent());
                     ruleSimpleDTO.setConType(conType);
                     BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
                     CoreUtil.addBeanToList(billMsgList, billMsg);
@@ -68,9 +70,9 @@ public class LisRule {
     public void highOperation(List<Lis> inputLis, RuleBaseDTO ruleBaseDTO, List<BillMsg> highRiskList, RuleSimpleDTO ruleSimpleDTO) {
         if (ListUtil.isNotEmpty(inputLis) && StringUtil.isNotBlank(ruleBaseDTO.getBaseLibName())) {
             for (Lis lis : inputLis) {
-                Map<String, Object> map = CoreUtil.compareLis(ruleBaseDTO, lis);
-                if (CoreUtil.getMapFlag(map)) {
-                    BillMsg billMsg = MsgUtil.getCommonHighRiskMsg((String) map.get("msg"), ruleSimpleDTO.getInputName(), ruleSimpleDTO.getLibTypeName());
+                MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lis);
+                if (matchDTO != null) {
+                    BillMsg billMsg = MsgUtil.getCommonHighRiskMsg(matchDTO.getContent(), ruleSimpleDTO.getInputName(), ruleSimpleDTO.getLibTypeName());
                     highRiskList.add(billMsg);
                 }
             }
@@ -84,8 +86,9 @@ public class LisRule {
      * @param ruleBaseDTOList
      * @param otherList
      * @param wordCrfDTO
+     * @param msg
      */
-    public void otherLis(Lis lisBean, List<RuleBaseDTO> ruleBaseDTOList, List<BillMsg> otherList, WordCrfDTO wordCrfDTO) {
+    public void otherLis(Lis lisBean, List<RuleBaseDTO> ruleBaseDTOList, List<BillMsg> otherList, WordCrfDTO wordCrfDTO, String msg) {
         if (ListUtil.isEmpty(ruleBaseDTOList)) {
             return ;
         }
@@ -98,19 +101,21 @@ public class LisRule {
                     case LisSubName: // 化验细项
                         if (ruleBaseDTO.getBaseLibName().equals(lisBean.getUniqueName())) {
                             // 化验自身
-                            map = CoreUtil.compareLis(ruleBaseDTO, lisBean);
-                            if (CoreUtil.getMapFlag(map)) {
+                            MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lisBean);
+                            if (matchDTO != null) {
                                 i++;
-                                lisOtherDTO.setName((String) map.get("msg"));
+                                lisOtherDTO.setName(matchDTO.getContent());
+                                lisOtherDTO.setLisNameDetail(matchDTO.getLisNameDetail());
                             } else {
                                 break;
                             }
                         } else {
                             // 其他化验——暂无数据
-                            map = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
-                            if (CoreUtil.getMapFlag(map)) {
+                            List<MatchDTO> matchDTOList = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
+                            if (ListUtil.isNotEmpty(matchDTOList)) {
                                 i++;
-                                lisOtherDTO.setLisMsg((List<String>) map.get("msgList"));
+                                List<String> msgLis = matchDTOList.stream().map(r -> r.getContent()).collect(Collectors.toList());
+                                lisOtherDTO.setLisMsg(msgLis);
                             } else {
                                 break;
                             }
@@ -145,42 +150,43 @@ public class LisRule {
         // 条件全部符合
         if (i == ruleBaseDTOList.size()) {
             if (StringUtil.isNotBlank(lisOtherDTO.getName())) {
+                String lisNameDetail = lisOtherDTO.getLisNameDetail(); // 化验套餐和明细
                 // 就化验本身一个条件符合
-                if (ListUtil.isEmpty(lisOtherDTO.getDiseaseMsg())
-                        && ListUtil.isEmpty(lisOtherDTO.getGroupMsg())
-                        && ListUtil.isEmpty(lisOtherDTO.getLisMsg())
-                        && ListUtil.isEmpty(lisOtherDTO.getDrugMsg())
-                ) {
-                    BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.lis.getName(),
-                            lisOtherDTO.getName(), "", TypeEnum.lisSelf.getName(), lisBean);
-                    otherList.add(billMsg);
+                if (i == 1) {
+                    BillMsg billMsg = msgNewUtil.getCommonOtherMsg(TypeEnum.lis.getName(),
+                            lisOtherDTO.getName(), "", TypeEnum.lisSelf.getName(), lisBean, msg, lisNameDetail);
+                    CoreUtil.addBeanToList(otherList, billMsg);
                 } else { // 有其他条件符合
                     // 诊断
                     if (ListUtil.isNotEmpty(lisOtherDTO.getDiseaseMsg())) {
                         for (String str : lisOtherDTO.getDiseaseMsg()) {
-                            BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(), str, TypeEnum.disease.getName(), lisBean);
-                            otherList.add(billMsg);
+                            BillMsg billMsg = msgNewUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(),
+                                    str, TypeEnum.disease.getName(), lisBean, msg, lisNameDetail);
+                            CoreUtil.addBeanToList(otherList, billMsg);
                         }
                     }
                     // 药品
                     if (ListUtil.isNotEmpty(lisOtherDTO.getDrugMsg())) {
                         for (String str : lisOtherDTO.getDrugMsg()) {
-                            BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(), str, TypeEnum.drug.getName(), lisBean);
-                            otherList.add(billMsg);
+                            BillMsg billMsg = msgNewUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(),
+                                    str, TypeEnum.drug.getName(), lisBean, msg, lisNameDetail);
+                            CoreUtil.addBeanToList(otherList, billMsg);
                         }
                     }
                     // 人群
                     if (ListUtil.isNotEmpty(lisOtherDTO.getGroupMsg())) {
                         for (String str : lisOtherDTO.getGroupMsg()) {
-                            BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(), str, TypeEnum.group.getName(), lisBean);
-                            otherList.add(billMsg);
+                            BillMsg billMsg = msgNewUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(),
+                                    str, TypeEnum.group.getName(), lisBean, msg, lisNameDetail);
+                            CoreUtil.addBeanToList(otherList, billMsg);
                         }
                     }
-                    // 化验
+                    // 化验——暂无数据
                     if (ListUtil.isNotEmpty(lisOtherDTO.getLisMsg())) {
                         for (String str : lisOtherDTO.getLisMsg()) {
-                            BillMsg billMsg = MsgUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(), str, TypeEnum.lis.getName(), lisBean);
-                            otherList.add(billMsg);
+                            BillMsg billMsg = msgNewUtil.getCommonOtherMsg(TypeEnum.lis.getName(), lisOtherDTO.getName(),
+                                    str, TypeEnum.lis.getName(), lisBean, msg, lisNameDetail);
+                            CoreUtil.addBeanToList(otherList, billMsg);
                         }
                     }
                 }
@@ -210,19 +216,21 @@ public class LisRule {
                     case LisSubName: // 化验细项
                         if (ruleBaseDTO.getBaseLibName().equals(lisBean.getUniqueName())) {
                             // 化验自身
-                            map = CoreUtil.compareLis(ruleBaseDTO, lisBean);
-                            if (CoreUtil.getMapFlag(map)) {
+                            MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lisBean);
+                            if (matchDTO != null) {
                                 i++;
-                                lisOtherDTO.setName((String) map.get("msg"));
+                                lisOtherDTO.setName(matchDTO.getContent());
+                                lisOtherDTO.setLisNameDetail(matchDTO.getLisNameDetail());
                             } else {
                                 break;
                             }
                         } else {
                             // 其他化验——暂无数据
-                            map = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
-                            if (CoreUtil.getMapFlag(map)) {
+                            List<MatchDTO> matchDTOList = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
+                            if (ListUtil.isNotEmpty(matchDTOList)) {
                                 i++;
-                                lisOtherDTO.setLisMsg((List<String>) map.get("msgList"));
+                                List<String> msgLis = matchDTOList.stream().map(r -> r.getContent()).collect(Collectors.toList());
+                                lisOtherDTO.setLisMsg(msgLis);
                             } else {
                                 break;
                             }
@@ -321,17 +329,17 @@ public class LisRule {
                     case LisSubName: // 化验细项
                         if (ruleBaseDTO.getBaseLibName().equals(lisBean.getUniqueName())) {
                             // 化验自身 【第一个】
-                            map = CoreUtil.compareLis(ruleBaseDTO, lisBean);
-                            if (CoreUtil.getMapFlag(map)) {
+                            MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lisBean);
+                            if (matchDTO != null) {
                                 i++;
-                                msg = (String) map.get("msg");
+                                msg = matchDTO.getContent();
                             } else {
                                 break;
                             }
                         } else {
                             // 其他化验
-                            map = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
-                            if (CoreUtil.getMapFlag(map)) {
+                            List<MatchDTO> matchDTOList = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
+                            if (ListUtil.isNotEmpty(matchDTOList)) {
                                 i++;
                             } else {
                                 break;
@@ -365,8 +373,8 @@ public class LisRule {
     public void push(List<Lis> inputLis, RuleBaseDTO ruleBaseDTO, List<Long> baseIdList, String ids) {
         if (ListUtil.isNotEmpty(inputLis) && StringUtil.isNotBlank(ruleBaseDTO.getBaseLibName())) {
             for (Lis lis : inputLis) {
-                Map<String, Object> map = CoreUtil.compareLis(ruleBaseDTO, lis);
-                if (CoreUtil.getMapFlag(map)) {
+                MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lis);
+                if (matchDTO != null) {
                     CoreUtil.addSplitString(baseIdList, ids);
                 }
             }

src/main/java/com/diagbot/rule/OtherRule.java

@@ -0,0 +1,134 @@
+package com.diagbot.rule;
+
+import com.diagbot.biz.push.entity.Item;
+import com.diagbot.biz.push.entity.Pacs;
+import com.diagbot.dto.BillMsg;
+import com.diagbot.dto.IndicationDTO;
+import com.diagbot.dto.RuleSimpleDTO;
+import com.diagbot.dto.WordCrfDTO;
+import com.diagbot.enums.ConEnum;
+import com.diagbot.enums.RedisEnum;
+import com.diagbot.enums.TypeEnum;
+import com.diagbot.model.entity.AllergyMedicine;
+import com.diagbot.model.entity.Negative;
+import com.diagbot.model.label.PastLabel;
+import com.diagbot.util.CoreUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.MsgNewUtil;
+import com.diagbot.util.RedisUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.Drug;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @description: 其他特殊规则
+ * @author: zhoutg
+ * @time: 2020/8/3 14:47
+ */
+@Component
+public class OtherRule {
+
+    @Autowired
+    MsgNewUtil msgNewUtil;
+    @Autowired
+    RedisUtil redisUtil;
+
+    /**
+     * 过敏原自身过敏，如果规则已维护，就不再比较；如果没有维护，比较是否与自身过敏
+     *
+     * @param
+     * @return
+     */
+    public void allergy(WordCrfDTO wordCrfDTO, IndicationDTO res) {
+        // 药物过敏源
+        PastLabel pastLabel = wordCrfDTO.getPastLabel();
+        List<AllergyMedicine> allergyMedicines = pastLabel.getAllergyMedicines();
+        if (ListUtil.isEmpty(wordCrfDTO.getDrugOrder()) || ListUtil.isEmpty(allergyMedicines)) {
+            return;
+        }
+        // 获取已维护的自身过敏规则，如果包含standName就不用再比较
+        Map<String, Integer> allergyMap = redisUtil.get(RedisEnum.drugAllergen.getName());
+        for (Drug drug : wordCrfDTO.getDrugOrder()) {
+            for (AllergyMedicine allergy : allergyMedicines) {
+                String name = allergy.getName();
+                String standName = allergy.getStandName();
+                Negative negative = allergy.getNegative(); // null表示阳性
+                if (allergyMap == null || !allergyMap.containsKey(standName)) {
+                    // 执行到这里说明自身过敏的规则没有维护
+                    if (negative == null && StringUtil.isNotBlank(drug.getUniqueName()) && drug.getUniqueName().equals(standName)) {
+                        RuleSimpleDTO ruleSimpleDTO = new RuleSimpleDTO();
+                        ruleSimpleDTO.setInputName(drug.getName());
+                        ruleSimpleDTO.setLibName(drug.getUniqueName());
+                        ruleSimpleDTO.setLibTypeName(TypeEnum.drug.getName());
+                        ruleSimpleDTO.setContent(name);
+                        ruleSimpleDTO.setConType(ConEnum.allergicmeds.getName());
+                        BillMsg billMsg = msgNewUtil.getCommonBillMsg(ruleSimpleDTO);
+                        CoreUtil.addBeanToList(res.getBillMsgList(), billMsg);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 七院需求：
+     * 非阻塞性睡眠呼吸暂停综合征和非混合性睡眠呼吸暂停综合征，不宜同时开立呼吸睡眠监测和眼电图(EOG)
+     *
+     * @param
+     * @return
+     */
+    public void smhxjcAndYdteog(WordCrfDTO wordCrfDTO, IndicationDTO res) {
+        // 七院特有
+        if (6 != wordCrfDTO.getHospitalId()) {
+            return;
+        }
+        // 1、比较是否包含2种诊断
+        List<Item> diagAllList = wordCrfDTO.getDiag(); // 结构化诊断
+        List<String> zsxList = Lists.newArrayList();// 阻塞性睡眠呼吸暂停综合征医院名称
+        List<String> hhxList = Lists.newArrayList();// 混合性睡眠呼吸暂停综合征医院名称
+        for (Item item : diagAllList) {
+            if ("阻塞性睡眠呼吸暂停综合征".equals(item.getUniqueName())) {
+                zsxList.add(item.getName());
+            } else if ("混合性睡眠呼吸暂停综合征".equals(item.getUniqueName())) {
+                hhxList.add((item.getName()));
+            }
+        }
+        // 如果两种疾病有其一，就不提示
+        if (ListUtil.isNotEmpty(zsxList) || ListUtil.isNotEmpty(hhxList)) {
+            return;
+        }
+
+        // 2、比较是否包含2种辅检开单项
+        List<Pacs> pacsList = wordCrfDTO.getPacsOrder(); // 辅检开单项
+        List<String> hxsmjcList = Lists.newArrayList();// 呼吸睡眠监测医院名称
+        List<String> ydteogList = Lists.newArrayList();// 眼电图(EOG)医院名称
+        for (Pacs pacs : pacsList) {
+            if ("呼吸睡眠监测".equals(pacs.getUniqueName())) {
+                hxsmjcList.add(pacs.getName());
+            } else if ("眼电图(EOG)".equals(pacs.getUniqueName())) {
+                ydteogList.add(pacs.getName());
+            }
+        }
+        // 辅检开单项必须有两个，否则就不提示
+        if (ListUtil.isEmpty(hxsmjcList) || ListUtil.isEmpty(ydteogList)) {
+            return;
+        }
+
+        // 3、提示语组合
+        List<BillMsg> billMsgList = res.getBillMsgList();
+        for (String hxsm : hxsmjcList) {
+            for (String ydt : ydteogList) {
+                BillMsg billMsg = new BillMsg();
+                billMsg.setType(TypeEnum.pacs.getName());
+                billMsg.setMsg(String.format("非阻塞性睡眠呼吸暂停综合征和非混合性睡眠呼吸暂停综合征患者，不宜同时开立%s和%s",
+                        hxsm, ydt));
+                billMsgList.add(billMsg);
+            }
+        }
+    }
+
+}

src/main/java/com/diagbot/rule/PacsRule.java

@@ -1,6 +1,7 @@
 package com.diagbot.rule;
 
 import com.diagbot.dto.BillMsg;
+import com.diagbot.dto.MatchDTO;
 import com.diagbot.dto.RuleBaseDTO;
 import com.diagbot.dto.RuleSimpleDTO;
 import com.diagbot.dto.WordCrfDTO;
@@ -130,8 +131,8 @@ public class PacsRule {
                         }
                         break;
                     case LisSubName: // 检验结果
-                        map = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
-                        if (CoreUtil.getMapFlag(map)) {
+                        List<MatchDTO> matchDTOList = CoreUtil.compareLis(ruleBaseDTO, wordCrfDTO.getLis());
+                        if (ListUtil.isNotEmpty(matchDTOList)) {
                             i++;
                         }
                         break;

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

@@ -1,13 +1,13 @@
 package com.diagbot.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.dto.GetAllForRelationDTO;
+import com.diagbot.dto.IndexBatchDTO;
 import com.diagbot.dto.IndexDTO;
 import com.diagbot.dto.KllisDetailDTO;
 import com.diagbot.dto.StaticKnowledgeIndexDTO;
 import com.diagbot.entity.KlConcept;
-import com.diagbot.vo.KllisDetailVO;
-import com.diagbot.vo.MedRetrievalVO;
-import com.diagbot.vo.StaticKnowledgeIndexVO;
+import com.diagbot.vo.*;
 
 import java.util.List;
 
@@ -23,7 +23,19 @@ public interface KlConceptService extends IService<KlConcept> {
 
     List<IndexDTO> index(MedRetrievalVO medRetrievalVO);
 
+    List<IndexBatchDTO> indexByApproval(IndexByApprovalVO indexByApprovalVO);
+
     List<StaticKnowledgeIndexDTO> staticIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO);
 
     List<KllisDetailDTO> getLisDetaisByNames(KllisDetailVO kllisDetailVO);
+
+    //查找（修改）
+    List<GetAllForRelationDTO> searchByTypeAndName(SearchConceptVO searchConceptVO);
+
+    //查找（新增）
+    List<GetAllForRelationDTO> searchByTypeAndNameAdd(SearchConceptVO searchConceptVO);
+
+    //查找（集合模块术语）
+    List<GetAllForRelationDTO> searchCollectionConcept(SearchCollectionConceptVO searchCollectionConceptVO);
+
 }

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

@@ -0,0 +1,16 @@
+package com.diagbot.service;
+
+import com.diagbot.entity.KlDiagnoseRecordDetail;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ * 诊断依据记录明细表 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+public interface KlDiagnoseRecordDetailService extends IService<KlDiagnoseRecordDetail> {
+
+}

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

@@ -0,0 +1,21 @@
+package com.diagbot.service;
+
+import com.diagbot.dto.DiagnoseRecordDTO;
+import com.diagbot.dto.ExportDiagnoseDTO;
+import com.diagbot.entity.KlDiagnoseRecord;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 诊断依据记录表 服务类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+public interface KlDiagnoseRecordService extends IService<KlDiagnoseRecord> {
+
+    List<DiagnoseRecordDTO> getDiagnoseRecord();
+}

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

@@ -2,15 +2,15 @@ package com.diagbot.service.impl;
 
 import com.baomidou.dynamic.datasource.annotation.DS;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.diagbot.dto.GetAllForRelationDTO;
+import com.diagbot.dto.IndexBatchDTO;
 import com.diagbot.dto.IndexDTO;
 import com.diagbot.dto.KllisDetailDTO;
 import com.diagbot.dto.StaticKnowledgeIndexDTO;
 import com.diagbot.entity.KlConcept;
 import com.diagbot.mapper.KlConceptMapper;
 import com.diagbot.service.KlConceptService;
-import com.diagbot.vo.KllisDetailVO;
-import com.diagbot.vo.MedRetrievalVO;
-import com.diagbot.vo.StaticKnowledgeIndexVO;
+import com.diagbot.vo.*;
 import org.springframework.stereotype.Service;
 
 import java.util.List;
@@ -32,6 +32,11 @@ public class KlConceptServiceImpl extends ServiceImpl<KlConceptMapper, KlConcept
         return baseMapper.index(medRetrievalVO);
     }
 
+    @Override
+    public List<IndexBatchDTO> indexByApproval(IndexByApprovalVO indexByApprovalVO){
+        return baseMapper.indexByApproval(indexByApprovalVO);
+    }
+
     @Override
     public List<StaticKnowledgeIndexDTO> staticIndex(StaticKnowledgeIndexVO staticKnowledgeIndexVO) {
         return baseMapper.staticIndex(staticKnowledgeIndexVO);
@@ -41,4 +46,20 @@ public class KlConceptServiceImpl extends ServiceImpl<KlConceptMapper, KlConcept
     public List<KllisDetailDTO> getLisDetaisByNames(KllisDetailVO kllisDetailVO) {
         return baseMapper.getLisDetaisByNames(kllisDetailVO);
     }
-}
+
+    @Override
+    public List<GetAllForRelationDTO> searchByTypeAndName(SearchConceptVO searchConceptVO) {
+        return baseMapper.searchByTypeAndName(searchConceptVO);
+    }
+
+    @Override
+    public List<GetAllForRelationDTO> searchByTypeAndNameAdd(SearchConceptVO searchConceptVO) {
+        return baseMapper.searchByTypeAndNameAdd(searchConceptVO);
+    }
+
+    @Override
+    public List<GetAllForRelationDTO> searchCollectionConcept(SearchCollectionConceptVO searchCollectionConceptVO) {
+        return baseMapper.searchCollectionConcept(searchCollectionConceptVO);
+    }
+
+}

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

@@ -0,0 +1,20 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.entity.KlDiagnoseRecordDetail;
+import com.diagbot.mapper.KlDiagnoseRecordDetailMapper;
+import com.diagbot.service.KlDiagnoseRecordDetailService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 诊断依据记录明细表 服务实现类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+@Service
+public class KlDiagnoseRecordDetailServiceImpl extends ServiceImpl<KlDiagnoseRecordDetailMapper, KlDiagnoseRecordDetail> implements KlDiagnoseRecordDetailService {
+
+}

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

@@ -0,0 +1,28 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.dto.DiagnoseRecordDTO;
+import com.diagbot.dto.ExportDiagnoseDTO;
+import com.diagbot.entity.KlDiagnoseRecord;
+import com.diagbot.mapper.KlDiagnoseRecordMapper;
+import com.diagbot.service.KlDiagnoseRecordService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 诊断依据记录表 服务实现类
+ * </p>
+ *
+ * @author zhoutg
+ * @since 2021-08-24
+ */
+@Service
+public class KlDiagnoseRecordServiceImpl extends ServiceImpl<KlDiagnoseRecordMapper, KlDiagnoseRecord> implements KlDiagnoseRecordService {
+
+    @Override
+    public List<DiagnoseRecordDTO> getDiagnoseRecord() {
+        return baseMapper.getDiagnoseRecord();
+    }
+}

src/main/java/com/diagbot/util/CatalogueUtil.java

@@ -153,41 +153,6 @@ public class CatalogueUtil {
         return false;
     }
 
-    /**
-     * 比较时间,以分钟为单位
-     * endDate比startDate多diff分钟则返回true
-     *
-     * @param startDate
-     * @param endDate
-     * @param diff
-     * @param hasEqual 是否包含“等号”
-     * @return
-     */
-    public static boolean compareTime(Date startDate, Date endDate, Long diff, boolean hasEqual) {
-        boolean overtime = false;
-        if (startDate == null || endDate == null) {
-            return false;
-        }
-        Calendar calendar_s = Calendar.getInstance();
-        Calendar calendar_e = Calendar.getInstance();
-        Long time_s, time_e;
-        try {
-            calendar_s.setTime(startDate);
-            calendar_e.setTime(endDate);
-
-            time_s = calendar_s.getTimeInMillis();
-            time_e = calendar_e.getTimeInMillis();
-            if (hasEqual) {
-                return Math.abs(time_e - time_s) >= diff * 1000 * 60;
-            } else {
-                return Math.abs(time_e - time_s) > diff * 1000 * 60;
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return overtime;
-    }
-
     /**
      * 获取查房记录标题中医师职称
      *

src/main/java/com/diagbot/util/Content.java

@@ -311,5 +311,6 @@ public class Content {
             "yyyy-MM-ddHH:mm:ss.000",
             "yyyyMMddHH:mm",
             "yyyy-MM-dd'T'HH:mm:ss",
+            "MM/dd/yyyyHH:mm:ss"
     };
 }

src/main/java/com/diagbot/util/CoreUtil.java

@@ -2,7 +2,7 @@ package com.diagbot.util;
 
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
-import com.diagbot.dto.PushBaseDTO;
+import com.diagbot.dto.MatchDTO;
 import com.diagbot.dto.RuleBaseDTO;
 import com.diagbot.enums.CommonEnum;
 import com.diagbot.enums.LexiconEnum;
@@ -20,7 +20,6 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 
 import java.lang.reflect.Field;
-import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
@@ -296,24 +295,23 @@ public class CoreUtil {
      * @param lisList
      * @return
      */
-    public static Map<String, Object> compareLis(RuleBaseDTO ruleBaseDTO, List<Lis> lisList) {
-        Map<String, Object> map = new LinkedHashMap<>();
-        boolean flag = false;
+    public static List<MatchDTO> compareLis(RuleBaseDTO ruleBaseDTO, List<Lis> lisList) {
         if (ruleBaseDTO == null || ListUtil.isEmpty(lisList)) {
-            map.put("flag", flag);
-            return map;
+            return null;
         }
-        List<String> msgList = new ArrayList<>();
+        boolean flag = false;
+        List<MatchDTO> matchDTOList = new ArrayList<>();
         for (Lis lis : lisList) {
-            Map mapLis = CoreUtil.compareLis(ruleBaseDTO, lis);
-            if (CoreUtil.getMapFlag(mapLis)) {
+            MatchDTO matchDTO = CoreUtil.compareLis(ruleBaseDTO, lis);
+            if (matchDTO != null) {
+                matchDTOList.add(matchDTO);
                 flag = true;
-                msgList.add((String) mapLis.get("msg"));
             }
         }
-        map.put("flag", flag);
-        map.put("msgList", msgList);
-        return map;
+        if (flag) {
+            return matchDTOList;
+        }
+        return null;
     }
 
     /**
@@ -323,58 +321,98 @@ public class CoreUtil {
      * @param lis
      * @return
      */
-    public static Map<String, Object> compareLis(RuleBaseDTO ruleBaseDTO, Lis lis) {
-        Map<String, Object> map = new LinkedHashMap<>();
-        boolean flag = false;
+    public static MatchDTO compareLis(RuleBaseDTO ruleBaseDTO, Lis lis) {
+        boolean flag = false; // 规则是否匹配
         if (ruleBaseDTO == null || lis == null) {
-            map.put("flag", flag);
-            return map;
+            return null;
         }
+        String unionName = ""; // 化验拼接名称，套餐+细项，细项
+        String content = ""; // 最终提示语
         String uniqueName = lis.getUniqueName();
         // 标准名称相同
         if (StringUtil.isNotBlank(uniqueName) && uniqueName.equals(ruleBaseDTO.getBaseLibName())) {
+            // 套餐和明细名称一样，优化提示语只取细项
+            if (StringUtil.isNotBlank(lis.getName()) && lis.getName().equals(lis.getDetailName())) {
+                unionName = lis.getDetailName(); // 取细项
+            } else {
+                unionName = lis.getName() + lis.getDetailName(); // 套餐+细项
+            }
             if (StringUtil.isNotBlank(lis.getOtherValue())) {
+                // 文本比较
                 if (lis.getOtherValue().equals(ruleBaseDTO.getBaseEqValue())) {
-                    // 套餐和明细名称一样，提示语只取其中一个
-                    if (StringUtil.isNotBlank(lis.getName()) && lis.getName().equals(lis.getDetailName())) {
-                        // 有医院原值就提示医院值
-                        if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getDetailName() + "结果" + lis.getResult());
-                        } else {
-                            map.put("msg", lis.getDetailName() + "结果" + lis.getOtherValue());
-                        }
+                    // 有医院原值就提示医院值
+                    if (StringUtil.isNotBlank(lis.getResult())) {
+                        content = unionName + "结果" + lis.getResult();
                     } else {
-                        // 有医院原值就提示医院值
-                        if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + lis.getResult());
-                        } else {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + lis.getOtherValue());
-                        }
+                        content = unionName + "结果" + lis.getOtherValue();
                     }
                     flag = true;
                 }
             } else if (lis.getValue() != null) {
+                // 数值比较
                 double value = lis.getValue();
                 flag = compareNum(ruleBaseDTO, value);
                 if (flag) {
-                    if (StringUtil.isNotBlank(lis.getName()) && lis.getName().equals(lis.getDetailName())) {
-                        if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getDetailName() + "结果" + lis.getResult());
-                        } else {
-                            map.put("msg", lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())));
-                        }
+                    // 获取化验单位拼接，默认会返回空字符串
+                    String unitsJoint = getJointUnits(lis);
+                    // 有医院原值就提示医院值，例如: 医院result字段: >10,技术服务部会将value设置成10.1，但提示语还是>10
+                    if (StringUtil.isNotBlank(lis.getResult())) {
+                        content = unionName + "结果" + lis.getResult() + unitsJoint;
                     } else {
-                        if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + lis.getResult());
-                        } else {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())));
-                        }
+                        content = unionName + "结果" + subZeroAndDot(String.valueOf(lis.getValue())) + unitsJoint;
                     }
                 }
             }
         }
-        map.put("flag", flag);
-        return map;
+        // 如果匹配返回对象
+        if (flag) {
+            MatchDTO matchDTO = new MatchDTO();
+            matchDTO.setContent(content);
+            matchDTO.setLisNameDetail(unionName);
+            return matchDTO;
+        }
+        return null;
+    }
+
+    /**
+     * 化验返回单位
+     *
+     * @param lis
+     * @return
+     */
+    public static String getJointUnits(Lis lis) {
+        String unitsJoint = "";
+        if (lis == null || StringUtil.isBlank(lis.getUnits())) {
+            return unitsJoint;
+        }
+        // 单位以数字开头，拼接“×”
+        boolean flag = RegexUtil.getRegexRes(lis.getUnits(), "^\\d");
+        if (flag) {
+            unitsJoint = "×" + lis.getUnits();
+        } else {
+            unitsJoint = lis.getUnits();
+        }
+        return unitsJoint;
+    }
+
+    /**
+     * 返回单位
+     *
+     * @param pd
+     * @return
+     */
+    public static String getJointUnits(PD pd) {
+        String unitsJoint = "";
+        if (pd == null || StringUtil.isBlank(pd.getUnit())) {
+            return unitsJoint;
+        }
+        boolean flag = RegexUtil.getRegexRes(pd.getUnit(), "^\\d");
+        if (flag) {
+            unitsJoint = "×" + pd.getUnit();
+        } else {
+            unitsJoint = pd.getUnit();
+        }
+        return unitsJoint;
     }
 
     /**
@@ -409,18 +447,22 @@ public class CoreUtil {
             // 体征数值比较(例如：体温，血压)
             for (Vital vital : vitalList) {
                 List<Usual> usualList = vital.getUsualList();
+                String unitsJoint = "";
+                // String unitsJoint = getJointUnits(vital.getPd()); // 获取查体单位拼接，单位容易提取错乱，先注释
                 if (ruleBaseDTO.getBaseLibName().equals(vital.getStandName()) && vital.getPd() != null
                         && StringUtil.isNotBlank(vital.getPd().getValue())) {
-                    flag = compareNum(ruleBaseDTO, Double.parseDouble(vital.getPd().getValue()));
-                    if (flag) {
-                        msgList.add(vital.getName() + subZeroAndDot(String.valueOf(vital.getPd().getValue())));
+                    if (CoreUtil.isNumbers(vital.getPd().getValue())) {
+                        flag = compareNum(ruleBaseDTO, Double.parseDouble(vital.getPd().getValue()));
+                        if (flag) {
+                            msgList.add(vital.getName() + subZeroAndDot(String.valueOf(vital.getPd().getValue())) + unitsJoint);
+                        }
                     }
                 } else if (ListUtil.isNotEmpty(usualList)) { // 血压比较
                     for (Usual usual : usualList) {
                         if (ruleBaseDTO.getBaseLibName().equals(usual.getStandName())) {
                             flag = compareNum(ruleBaseDTO, Double.parseDouble(usual.getValue()));
                             if (flag) {
-                                msgList.add(vital.getName() + subZeroAndDot(String.valueOf(vital.getPd().getValue())));
+                                msgList.add(vital.getName() + subZeroAndDot(String.valueOf(vital.getPd().getValue())) + unitsJoint);
                             }
                         }
                     }
@@ -633,69 +675,6 @@ public class CoreUtil {
         debugMap.put(msg, error);
     }
 
-    /**
-     * 年龄字符串转换成double类型
-     *
-     * @param ageStr
-     * @return
-     */
-    public static Double convertAge(String ageStr) {
-        try {
-            // 防止程序出错
-            if (StringUtil.isEmpty(ageStr)) {
-                return 20.0;
-            }
-            // 数值,当成年龄处理
-            if (isNumbers(ageStr)) {
-                return Double.parseDouble(ageStr);
-            }
-            // 20日
-            if (ageStr.endsWith("日")) {
-                return getHalfUp((Double.parseDouble(ageStr.substring(0, ageStr.length() - 1))) / 365);
-            }
-            // 3岁
-            if (ageStr.endsWith("岁")) {
-                return Double.parseDouble(ageStr.substring(0, ageStr.length() - 1));
-            }
-            // 3岁7个月 | 3岁7月
-            if (ageSuiYue(ageStr)) {
-                String[] ageArr = new String[2];
-                int indexSui = ageStr.indexOf("岁");
-                ageArr[0] = ageStr.substring(0, indexSui);
-                if (ageStr.indexOf("个月") > -1) { // 3岁7个月
-                    ageArr[1] = ageStr.substring(indexSui + 1, ageStr.indexOf("个月"));
-                } else { // 3岁7月
-                    ageArr[1] = ageStr.substring(indexSui + 1, ageStr.indexOf("月"));
-                }
-                return Double.parseDouble(ageArr[0]) + getHalfUp(Double.parseDouble(ageArr[1]) / 12);
-            }
-            // 1.08月 | .11月 | 3月
-            if (ageYue(ageStr)) {
-                String noUnit = ageStr.substring(0, ageStr.length() - 1);
-                String[] ageArr = new String[2];
-                String[] splitArr = noUnit.split("\\.");
-                if (splitArr.length == 1) {
-                    ageArr[0] = splitArr[0];
-                } else if (splitArr.length == 2) {
-                    ageArr[0] = splitArr[0];
-                    ageArr[1] = splitArr[1];
-                }
-                Double daySum = 0.0D;
-                if (StringUtil.isNotBlank(ageArr[0])) {
-                    daySum += Double.parseDouble(ageArr[0]) * 30;
-                }
-                if (StringUtil.isNotBlank(ageArr[1])) {
-                    daySum += Double.parseDouble(ageArr[1]);
-                }
-                return getHalfUp(daySum / 365);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-            return 20.0;
-        }
-        return 20.0;
-    }
-
     /**
      * 判断字符串是否 仅 包含数字
      *
@@ -718,40 +697,6 @@ public class CoreUtil {
         return str.matches(regex);
     }
 
-
-    /**
-     * 判断年龄字符串：xx月
-     *
-     * @param str
-     * @return
-     */
-    public static boolean ageYue(String str) {
-        String regex = "^[0-9]*[\\.]*[0-9]{1,2}月$";
-        return str.matches(regex);
-    }
-
-    /**
-     * 判断年龄字符串：3岁7个月
-     *
-     * @param str
-     * @return
-     */
-    public static boolean ageSuiYue(String str) {
-        String regex = "^[0-9]{1,3}岁[0-9]{1,2}个{0,1}月$";
-        return str.matches(regex);
-    }
-
-    /**
-     * 四舍五入保留2位小数
-     *
-     * @param ageStr
-     * @return
-     */
-    public static Double getHalfUp(Double ageStr) {
-        BigDecimal bg = new BigDecimal(String.valueOf(ageStr));
-        return bg.setScale(3, BigDecimal.ROUND_HALF_UP).doubleValue();
-    }
-
     /**
      * 替换首位的标点符号(例如：既往史提取“铁)
      *
@@ -1041,7 +986,7 @@ public class CoreUtil {
                 if (StringUtil.isNotBlank(value1)) {
                     unionKey += value1;
                 }
-                unionKey += "*****";
+                unionKey += CommonEnum.splitSymbol.getName();
                 if (StringUtil.isNotBlank(value2)) {
                     unionKey += value2;
                 }
@@ -1203,15 +1148,16 @@ public class CoreUtil {
     }
 
     /**
-     * 时间差值(绝对值)和指定分钟数进行比较
+     * 时间差值（endDateStr - startDateStr）和指定分钟数进行比较
      *
      * @param startDateStr 开始时间
      * @param endDateStr   结束时间
      * @param minute       分钟
      * @param hasEqual     是否包含等于
+     * @param abs          是否加绝对值
      * @return 返回值：-1：无法比较或出错，0：时间差超出范围，1：时间差在范围内
      */
-    public static int compareTime(String startDateStr, String endDateStr, Long minute, boolean hasEqual) {
+    public static int compareTime(String startDateStr, String endDateStr, Long minute, boolean hasEqual, boolean abs) {
         int flag = -1;
         if (StringUtil.isBlank(startDateStr) || StringUtil.isBlank(endDateStr)) {
             return flag;
@@ -1221,15 +1167,23 @@ public class CoreUtil {
             Date endDate = CatalogueUtil.parseStringDate(endDateStr);
             Long timeStart = startDate.getTime();
             Long timeEnd = endDate.getTime();
-
+            Long timeDiff = timeEnd - timeStart;// 时间差
+            // 是否加绝对值
+            if (abs) {
+                timeDiff = Math.abs(timeDiff);// 时间差绝对值
+            } else {
+                if (timeDiff < 0) {
+                    return flag;
+                }
+            }
             if (hasEqual) {
-                if (Math.abs(timeEnd - timeStart) >= minute * 1000 * 60) {
+                if (timeDiff >= minute * 1000 * 60) {
                     flag = 0;
                 } else {
                     flag = 1;
                 }
             } else {
-                if (Math.abs(timeEnd - timeStart) > minute * 1000 * 60) {
+                if (timeDiff > minute * 1000 * 60) {
                     flag = 0;
                 } else {
                     flag = 1;
@@ -1269,17 +1223,22 @@ public class CoreUtil {
     }
 
     public static void main(String[] args) {
-        List<PushBaseDTO> pushBaseDTOList = ListUtil.newArrayList();
-        PushBaseDTO pushBaseDTO = new PushBaseDTO();
-        pushBaseDTO.setName("a1");
-        pushBaseDTOList.add(pushBaseDTO);
-
-        PushBaseDTO pushBaseDTO1 = new PushBaseDTO();
-        pushBaseDTO1.setName("a1");
-        pushBaseDTOList.add(pushBaseDTO1);
-
-        removeRepeat(pushBaseDTOList, "name");
-        System.out.println(pushBaseDTOList);
+        System.out.println(isNumbers("1.1"));
+        System.out.println(isNumbers("1.."));
+        System.out.println(isNumbers("a1."));
+        System.out.println(isNumbers("1.b"));
+        System.out.println(isNumbers(".9"));
+        // List<PushBaseDTO> pushBaseDTOList = ListUtil.newArrayList();
+        // PushBaseDTO pushBaseDTO = new PushBaseDTO();
+        // pushBaseDTO.setName("a1");
+        // pushBaseDTOList.add(pushBaseDTO);
+        //
+        // PushBaseDTO pushBaseDTO1 = new PushBaseDTO();
+        // pushBaseDTO1.setName("a1");
+        // pushBaseDTOList.add(pushBaseDTO1);
+        //
+        // removeRepeat(pushBaseDTOList, "name");
+        // System.out.println(pushBaseDTOList);
 
         // List<String> list = Lists.newArrayList("a","b","a");
         // list = removeRepeat(list);

src/main/java/com/diagbot/util/ExtUtil.java

@@ -23,15 +23,16 @@ public class ExtUtil {
      *
      * @param list
      * @param property
+     * @param <K>
      * @param <V>
      * @return
      */
-    public static <V> Map<String, List<V>> getKeyList(List<V> list, String property) {
+    public static <K, V> Map<K, List<V>> getKeyList(List<V> list, String property) {
         if (ListUtil.isEmpty(list)) {
             return new LinkedHashMap<>();
         }
         return list.stream().collect(
-                Collectors.groupingBy(k -> ReflectUtil.getProperty(k, property)));
+                Collectors.groupingBy(r -> ReflectUtil.getProperty(r, property), LinkedHashMap::new, Collectors.toList()));
     }
 
     /**
@@ -39,22 +40,23 @@ public class ExtUtil {
      *
      * @param list
      * @param property
+     * @param <K>
      * @param <V>
      * @return
      */
-    public static <V> Map<String, V> getKeyObject(List<V> list, String property) {
+    public static <K, V> Map<K, V> getKeyObject(List<V> list, String property) {
         if (ListUtil.isEmpty(list)) {
             return new LinkedHashMap<>();
         }
         return list.stream().collect(
-                Collectors.toMap(k -> ReflectUtil.getProperty(k, property), v -> v, (v1, v2) -> (v2)));
+                Collectors.toMap(k -> ReflectUtil.getProperty(k, property), v -> v, (v1, v2) -> (v2), LinkedHashMap::new));
     }
 
     /**
      * 以Map<key, V> 形式返回，如果key相同，会覆盖前面的内容
      *
-     * @param list 列表
-     * @param splitSmybool key分隔符
+     * @param list          列表
+     * @param splitSmybool  key分隔符
      * @param multiProperty 多个属性
      * @param <V>
      * @return
@@ -64,19 +66,19 @@ public class ExtUtil {
             return new LinkedHashMap<>();
         }
         return list.stream().collect(Collectors.toMap(k -> {
-            List<String> key = Lists.newArrayList();
+            List<String> keyList = Lists.newArrayList();
             for (String property : multiProperty) {
-                key.add(ReflectUtil.getProperty(k, property));
+                keyList.add(ReflectUtil.getProperty(k, property));
             }
-            return StringUtils.join(key, splitSmybool);
-        }, v -> v, (v1, v2) -> (v2)));
+            return StringUtils.join(keyList, splitSmybool);
+        }, v -> v, (v1, v2) -> (v2), LinkedHashMap::new));
     }
 
     /**
      * 以Map<key, List<V>> 形式返回
      *
-     * @param list 列表
-     * @param splitSmybool key分隔符
+     * @param list          列表
+     * @param splitSmybool  key分隔符
      * @param multiProperty 多个属性
      * @param <V>
      * @return
@@ -86,12 +88,12 @@ public class ExtUtil {
             return new LinkedHashMap<>();
         }
         return list.stream().collect(Collectors.groupingBy(k -> {
-            List<String> key = Lists.newArrayList();
+            List<String> keyList = Lists.newArrayList();
             for (String property : multiProperty) {
-                key.add(ReflectUtil.getProperty(k, property));
+                keyList.add(ReflectUtil.getProperty(k, property));
             }
-            return StringUtils.join(key, splitSmybool);
-        }));
+            return StringUtils.join(keyList, splitSmybool);
+        }, LinkedHashMap::new, Collectors.toList()));
     }
 
     /**
@@ -109,7 +111,7 @@ public class ExtUtil {
             return new LinkedHashMap<>();
         }
         return list.stream().collect(Collectors.toMap(k -> ReflectUtil.getProperty(k, keyProperty),
-                v -> ReflectUtil.getProperty(v, valueProperty), (v1, v2) -> (v2)));
+                v -> ReflectUtil.getProperty(v, valueProperty), (v1, v2) -> (v2), LinkedHashMap::new));
     }
 
     /**
@@ -217,5 +219,6 @@ public class ExtUtil {
 
     public static void main(String[] args) {
 
+
     }
 }

src/main/java/com/diagbot/util/MsgNewUtil.java

@@ -1,9 +1,11 @@
 package com.diagbot.util;
 
+import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.dto.BillMsg;
 import com.diagbot.dto.RuleSimpleDTO;
 import com.diagbot.enums.ConEnum;
 import com.diagbot.enums.RedisEnum;
+import com.diagbot.enums.TypeEnum;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
@@ -31,6 +33,7 @@ public class MsgNewUtil {
         String content = ruleSimpleDTO.getContent(); // 界面匹配内容
         String conType = ruleSimpleDTO.getConType(); // 禁忌类型
         String unionMsg = ruleSimpleDTO.getMsg(); // 原因及建议
+        String structName = ruleSimpleDTO.getStructName(); // 项目名称
         String msg = redisUtil.getByKeyAndField(RedisEnum.msg.getName(), orderType + "_" + conType);
         if (StringUtil.isBlank(msg)) {
             // msg = redisUtil.getByKeyAndField(RedisEnum.msg.getName(), "通用" + "_" + "默认提示语");
@@ -58,7 +61,9 @@ public class MsgNewUtil {
 
         // 放到最后统一替换【多处匹配】
         msg = msg.replaceAll("\\[匹配内容]", content);
-        msg = msg.replaceAll("\\[开单名称]", orderName);
+        String orderNameNew = orderName.replaceAll("\\\\","\\\\\\\\"); // 防止开单名称中有\\
+        msg = msg.replaceAll("\\[开单名称]", orderNameNew);
+        msg = msg.replaceAll("\\[项目名称]", structName);
         billMsg.setMsg(msg);
         billMsg.setOrderName(orderName);
         billMsg.setOrderStandName(orderStandName);
@@ -66,4 +71,46 @@ public class MsgNewUtil {
         billMsg.setType(conType);
         return billMsg;
     }
+
+    /**
+     * 其他值通用提示信息
+     *
+     * @param content
+     * @param name
+     * @param type
+     * @param lis
+     * @param suggestMsg
+     * @return
+     */
+    public BillMsg getCommonOtherMsg(String otherType, String content, String name, String type, Lis lis, String suggestMsg, String lisNameDetail) {
+        BillMsg billMsg = new BillMsg();
+        String msg = "";
+        switch (TypeEnum.getEnum(otherType)) {
+            case lis: // 其他值提醒——化验
+                msg = redisUtil.getByKeyAndField(RedisEnum.otherMsg.getName(), otherType + "_" + type);
+                if (StringUtil.isBlank(msg)) { // 防止报空指针
+                    return null;
+                }
+                if (StringUtil.isNotBlank(suggestMsg)) {
+                    msg = msg.replaceAll("\\[原因及建议]", "，" + suggestMsg);
+                } else {
+                    msg = msg.replaceAll("\\[原因及建议]", "");
+                }
+                // 放到最后统一替换【多处匹配】
+                msg = msg.replaceAll("\\[化验结果]", content);
+                msg = msg.replaceAll("\\[匹配内容]", name);
+                if (msg.contains("[化验套餐和明细]")) {
+                    msg = msg.replaceAll("\\[化验套餐和明细]", lisNameDetail);
+                }
+                billMsg.setType(type);
+                billMsg.setOrderName(lis.getName());
+                billMsg.setOrderDetailName(lis.getDetailName());
+                break;
+            default:
+                break;
+        }
+        billMsg.setMsg(msg);
+        billMsg.setContent(content);
+        return billMsg;
+    }
 }

src/main/java/com/diagbot/util/MsgUtil.java

@@ -99,6 +99,8 @@ public class MsgUtil {
             case transfusion: // 其他值提醒——输血
                 msg = String.format("该患者%s，建议输注%s", content, name);
                 break;
+            case other: // 其他特殊规则
+                msg = content;
             default:
                 break;
         }

src/main/java/com/diagbot/util/RedisUtil.java

@@ -67,10 +67,10 @@ public class RedisUtil {
      * 根据指定key设置obj
      *
      * @param key
-     * @param obj
+     * @param t
      */
-    public void set(String key, Object obj) {
-        redisTemplate.opsForValue().set(key, obj);
+    public <T> void set(String key, T t) {
+        redisTemplate.opsForValue().set(key, t);
     }
 
     /**
@@ -89,7 +89,7 @@ public class RedisUtil {
      * @param map
      * @return
      */
-    public void multiSet(Map<String, Object> map) {
+    public <T> void multiSet(Map<String, T> map) {
         redisTemplate.opsForValue().multiSet(map);
     }
 
@@ -262,40 +262,28 @@ public class RedisUtil {
         return redisTemplate.renameIfAbsent(oldKey, newKey);
     }
 
-    /** -------------------string相关操作--------------------- */
-
-    /**
-     * 设置指定 key 的值
-     *
-     * @param key
-     * @param value
-     */
-    public void set(String key, String value) {
-        redisTemplate.opsForValue().set(key, value);
-    }
-
     /**
      * 将值 value 关联到 key ，并将 key 的过期时间设为 timeout
      *
      * @param key
-     * @param value
+     * @param t
      * @param timeout 过期时间
      * @param unit    时间单位, 天:TimeUnit.DAYS 小时:TimeUnit.HOURS 分钟:TimeUnit.MINUTES
      *                秒:TimeUnit.SECONDS 毫秒:TimeUnit.MILLISECONDS
      */
-    public void setEx(String key, String value, long timeout, TimeUnit unit) {
-        redisTemplate.opsForValue().set(key, value, timeout, unit);
+    public <T> void setEx(String key, T t, long timeout, TimeUnit unit) {
+        redisTemplate.opsForValue().set(key, t, timeout, unit);
     }
 
     /**
      * 只有在 key 不存在时设置 key 的值
      *
      * @param key
-     * @param value
+     * @param t
      * @return 之前已经存在返回false, 不存在返回true
      */
-    public boolean setIfAbsent(String key, String value) {
-        return redisTemplate.opsForValue().setIfAbsent(key, value);
+    public <T> boolean setIfAbsent(String key, T t) {
+        return redisTemplate.opsForValue().setIfAbsent(key, t);
     }
 
     /**
@@ -304,7 +292,7 @@ public class RedisUtil {
      * @param key
      * @param map
      */
-    public void putHashMap(String key, Map<String, Object> map) {
+    public <T> void putHashMap(String key, Map<String, T> map) {
         if (MapUtils.isNotEmpty(map)) {
             redisTemplate.opsForHash().putAll(key, map);
         }

src/main/java/com/diagbot/util/RegexUtil.java

@@ -40,16 +40,12 @@ public class RegexUtil {
     /**
      * 是否有符合正则的数据（大小写敏感）
      *
-     * @param content 文本内容
-     * @param regex   表达式
-     * @param senstive 大小写是否敏感
+     * @param content  文本内容
+     * @param regex    表达式
      * @return
      */
-    public static Boolean getRegexRes(String content, String regex, boolean senstive) {
-        if (senstive) {
-            return getRegexResCommon(content, regex, true);
-        }
-        return getRegexResCommon(content, regex, false);
+    public static Boolean getRegexResSen(String content, String regex) {
+        return getRegexResCommon(content, regex, true);
     }
 
     /**
@@ -79,7 +75,7 @@ public class RegexUtil {
     /**
      * 获取pattern
      *
-     * @param regex 正则表达式
+     * @param regex     正则表达式
      * @param sensitive 大小写敏感
      * @return
      */
@@ -94,7 +90,7 @@ public class RegexUtil {
     }
 
     /**
-     * 根据正则获取指定分组数据（大小写不敏感）
+     * 根据正则获取第一个匹配的指定分组数据（大小写不敏感）
      *
      * @param content  文本内容
      * @param regex    表达式
@@ -106,22 +102,19 @@ public class RegexUtil {
     }
 
     /**
-     * 根据正则获取指定分组数据（大小写敏感）
+     * 根据正则获取第一个匹配的指定分组数据（大小写敏感）
      *
      * @param content  文本内容
      * @param regex    表达式
      * @param groupNum 获取第几个内容
      * @return
      */
-    public static String getRegexData(String content, String regex, Integer groupNum, Boolean sensitive) {
-        if (sensitive) {
-            return getRegexDataCommon(content, regex, groupNum, true);
-        }
-        return getRegexDataCommon(content, regex, groupNum, false);
+    public static String getRegexDataSen(String content, String regex, Integer groupNum) {
+        return getRegexDataCommon(content, regex, groupNum, true);
     }
 
     /**
-     * 根据正则获取指定分组数据（公共方法）
+     * 根据正则获取第一个匹配的指定分组数据（公共方法）
      *
      * @param content  文本内容
      * @param regex    表达式
@@ -148,38 +141,35 @@ public class RegexUtil {
     }
 
     /**
-     * 根据正则获取所有分组数据（大小写不敏感）
+     * 根据正则获取第一个匹配的所有分组数据（大小写不敏感）
      *
      * @param content
      * @param regex
      * @return
      */
-    public static List<String> getRegexData(String content, String regex) {
-        return getRegexDataCommon(content, regex, false);
+    public static List<String> getRegexDataList(String content, String regex) {
+        return getRegexDataListCommon(content, regex, false);
     }
 
     /**
-     * 根据正则获取所有分组数据（大小写敏感）
+     * 根据正则获取第一个匹配的所有分组数据（大小写敏感）
      *
      * @param content
      * @param regex
      * @return
      */
-    private static List<String> getRegexData(String content, String regex, Boolean sensitive) {
-        if (sensitive) {
-            getRegexDataCommon(content, regex, true);
-        }
-        return getRegexDataCommon(content, regex, false);
+    public static List<String> getRegexDataListSen(String content, String regex) {
+        return getRegexDataListCommon(content, regex, true);
     }
 
     /**
-     * 根据正则获取所有分组数据（内部方法）
+     * 根据正则获取第一个匹配的所有分组数据（内部方法）
      *
      * @param content
      * @param regex
      * @return
      */
-    private static List<String> getRegexDataCommon(String content, String regex, Boolean sensitive) {
+    private static List<String> getRegexDataListCommon(String content, String regex, Boolean sensitive) {
         List<String> list = Lists.newArrayList();
         try {
             if (StringUtil.isBlank(content)) {
@@ -198,18 +188,51 @@ public class RegexUtil {
         return list;
     }
 
-    public static List<String> getRegexDatas(String content, String pattern){
-        List<String> numbers=new ArrayList<>();
-        // 创建 Pattern 对象
-        Pattern r = Pattern.compile(pattern);
-        // 现在创建 matcher 对象
-        Matcher matcher = r.matcher(content);
-        while (matcher.find()) {
-            //获取当前匹配的值
-            numbers.add(matcher.group());
-        }
+    /**
+     * 根据正则获取所有匹配数据（大小写不敏感）
+     *
+     * @param content
+     * @param regex
+     * @return
+     */
+    public static List<String> getRegexDataAll(String content, String regex) {
+        return getRegexDataAllCommon(content, regex, false);
+    }
 
-        return numbers;
+    /**
+     * 根据正则获取所有匹配数据（大小写敏感）
+     *
+     * @param content
+     * @param regex
+     * @return
+     */
+    public static List<String> getRegexDataAllSen(String content, String regex) {
+        return getRegexDataAllCommon(content, regex, true);
+    }
+
+    /**
+     * 根据正则获取所有匹配数据（内部方法）
+     *
+     * @param content
+     * @param regex
+     * @return
+     */
+    private static List<String> getRegexDataAllCommon(String content, String regex, Boolean sensitive) {
+        List<String> list = Lists.newArrayList();
+        try {
+            if (StringUtil.isBlank(content)) {
+                return list;
+            }
+            Pattern pattern = getPattern(regex, sensitive);
+            Matcher matcher = pattern.matcher(content);
+            while (matcher.find()) {
+                //获取当前匹配的值
+                list.add(matcher.group());
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return list;
     }
 
     /**
@@ -218,19 +241,21 @@ public class RegexUtil {
      * @param args
      */
     public static void main(String[] args) {
-        String regex1 = "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])";
-        // System.out.println(getRegexData("血小板计数  30.3", regex1, 2));
-        System.out.println(getRegexData("拟诊+(3.3/3.4)任一", regex1));
+        String str = "1-2-3-4, 法法，0-0-1-0";
+        String regex = "(\\d+)-(\\d+)-(\\d+)-(\\d+)";
+        System.out.println(getRegexDataList(str, regex));
 
-        String s1 = "ABC";
-        System.out.println(getRegexRes(s1, "Abc", true));
+        // String regex1 = "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])";
+        // // System.out.println(getRegexData("血小板计数  30.3", regex1, 2));
+        // System.out.println(getRegexData("拟诊+(3.3/3.4)任一", regex1));
+        //
+        // String s1 = "ABC";
+        // System.out.println(getRegexRes(s1, "Abc", true));
 
-        System.out.println(getRegexDatas("拟诊+(3.3/3.4)任一","([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])"));
+        System.out.println(getRegexDataAll("拟诊+(3.3/3.4)任一", "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9])"));
 
         ArrayList<String> js = Lists.newArrayList("G.4", "G.1", "G.2", "G.3");
         List<String> collect = js.stream().sorted().collect(Collectors.toList());
         System.out.println(collect);
-
-
     }
 }

src/main/java/com/diagbot/vo/ConceptVO.java

@@ -17,4 +17,5 @@ public class ConceptVO {
     private List<String> names;
     private Integer type;
     private Integer source;
+    private Integer status;
 }

src/main/java/com/diagbot/vo/FilterVO.java

@@ -15,4 +15,5 @@ import javax.validation.constraints.NotBlank;
 public class FilterVO {
     @NotBlank(message = "请输入检索内容")
     private String inputStr;
+    private Integer status;
 }

src/main/java/com/diagbot/vo/ImportDiagnoseResVO.java

@@ -1,5 +1,6 @@
 package com.diagbot.vo;
 
+import com.diagbot.dto.KlDiagnoseRecordDTO;
 import com.google.common.collect.Lists;
 import lombok.Data;
 
@@ -23,4 +24,6 @@ public class ImportDiagnoseResVO implements Serializable {
     private String diseaseName;
     // 导入数据
     private List<ImportDiagnoseVO> importDiagnoseVOList = Lists.newArrayList();
+    // 导入记录
+    private List<KlDiagnoseRecordDTO> recordList = Lists.newArrayList();
 }

src/main/java/com/diagbot/vo/ImportDiagnoseVO.java

@@ -27,19 +27,21 @@ public class ImportDiagnoseVO implements Serializable, IExcelDataModel {
     @Excel(name = "规则")
     private String rule = "";
     @Excel(name = "等于")
-    private String eq;
+    private String eqValue;
     @Excel(name = "最大值")
-    private String max;
+    private String maxValue;
     @Excel(name = "最大值符号")
-    private String maxSymbol;
+    private String maxOperator;
     @Excel(name = "单位")
     private String unit;
     @Excel(name = "最小值")
-    private String min;
+    private String minValue;
     @Excel(name = "最小值符号")
-    private String minSymbol;
+    private String minOperator;
     // @Excel(name="单位")
     // private String minUnit;
+    @Excel(name = "关联词")
+    private String description;;
 
     // 规则标准词id
     private List<Long> conceptId;

src/main/java/com/diagbot/vo/IndexByApprovalVO.java

@@ -0,0 +1,22 @@
+package com.diagbot.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/8/24 15:49
+ */
+@Data
+public class IndexByApprovalVO {
+    /**
+     * 国药准字列表
+     */
+    private List<String> approvalList;
+    /**
+     * 标准术语禁用启用状态
+     */
+    private Integer status;
+}

src/main/java/com/diagbot/vo/SearchCollectionConceptVO.java

@@ -0,0 +1,49 @@
+package com.diagbot.vo;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+/**
+ * @className: com.diagbot.vo-> SearchCollectionConceptVO
+ * @description: 在集合业务中，搜索术语
+ * @author: kongwz
+ * @createDate: 2021-08-18 16:07
+ * @version: 1.0
+ * @todo:
+ */
+@Setter
+@Getter
+public class SearchCollectionConceptVO {
+    /**
+     * 词性id
+     */
+    @ApiModelProperty(value="词性id")
+    @NotNull(message ="请输入搜索词的词性" )
+    private Integer libType;
+    /**
+     * 需要排除的概念id集合
+     */
+    @ApiModelProperty(value="需要排除的概念id集合")
+    private List<Long> excludedConceptIds;
+
+    @ApiModelProperty(value="搜索关键词")
+    private List<String> names;
+
+    @ApiModelProperty(value="逻辑运算符")
+    @NotNull(message ="请输入逻辑运算符" )
+    private Integer logicalOperator;
+
+    @Override
+    public String toString() {
+        return "SearchCollectionConceptVO{" +
+                "libType=" + libType +
+                ", excludedConceptIds=" + excludedConceptIds +
+                ", names=" + names +
+                ", logicalOperator=" + logicalOperator +
+                '}';
+    }
+}

src/main/java/com/diagbot/vo/SearchConceptVO.java

@@ -4,7 +4,6 @@ import io.swagger.annotations.ApiModelProperty;
 import lombok.Getter;
 import lombok.Setter;
 
-import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.NotNull;
 import java.util.List;
 
@@ -17,7 +16,6 @@ import java.util.List;
 @Getter
 public class SearchConceptVO {
     @ApiModelProperty(value="名称")
-    @NotBlank(message = "请输入搜索名称")
     private String name;
     /**
      * 词性id
@@ -30,4 +28,11 @@ public class SearchConceptVO {
      */
     @ApiModelProperty(value="需要排除的概念id集合")
     private List<Long> excludedConceptIds;
+
+    /**
+     * 标志（新增 -1 修改 2）
+     */
+//    @ApiModelProperty(value="新增修改标志")
+//    @NotBlank(message = "请输入标志")
+//    private Integer sign;
 }

src/main/java/com/diagbot/vo/SearchData.java

@@ -3,6 +3,7 @@ package com.diagbot.vo;
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.biz.push.entity.Pacs;
+import com.diagbot.biz.push.entity.Scale;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Getter;
 import lombok.Setter;
@@ -176,4 +177,12 @@ public class SearchData extends HospitalBaseVO {
      * 其他指标
      */
     private Map<String, String> otherIndex;
+    /**
+     * 其他医嘱
+     */
+    private List<Item> otherAdvice = new ArrayList<>();
+    /**
+     * 量表结果
+     */
+    private List<Scale> scale = new ArrayList<>();
 }

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

@@ -45,7 +45,8 @@ public class CacheController {
         cacheFacade.loadDeptPush(); // 重新加载标准科室和推送类型的映射关系
         cacheFacade.loadFrequency(); // 重新加载频次
         conceptInfoFacade.loadCustomDictionary(); // 重新加载NLP分词字典
-        cacheFacade.loadMsg();
+        cacheFacade.loadMsg(); // 加载开单提示语
+        cacheFacade.loadVteAdviceCache(); // 重新加载vte医嘱数据
         cacheFacade.loadAllBaseDiagnoseCache(); // 重新加载诊断依据
         cacheFacade.loadAllRuleCache(); // 重新加载开单规则
         return RespDTO.onSuc(true);

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

@@ -44,7 +44,13 @@ public class KlDiagnoseImportController {
     @ApiOperation(value = "诊断依据导出API[zhoutg]")
     @PostMapping("/exportDiagnose")
     public void exportDiagnose(HttpServletResponse response) {
-        klDiagnoseDetailFacade.exportDiagnose(response);
+        klDiagnoseDetailFacade.exportDiagnoseDetail(response);
+    }
+
+    @ApiOperation(value = "【记录导出】诊断依据导出API[zhoutg]")
+    @PostMapping("/exportDiagnoseRecord")
+    public void exportDiagnoseRecord(HttpServletResponse response) {
+        klDiagnoseDetailFacade.exportDiagnoseRecord(response);
     }
 
 }

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

@@ -31,6 +31,7 @@ public class KlDictionaryConller {
     @PostMapping("/getDictionaryInfo")
     @SysLogger("getDictionaryInfo")
     public RespDTO<Map<Long, List<DictionaryInfoDTO>>> getDictionaryInfoAll() {
+
         return RespDTO.onSuc(dictionaryFacade.getListBack());
     }
 }

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

@@ -5,6 +5,7 @@ import com.diagbot.annotation.SysLogger;
 import com.diagbot.dto.GetAllForRelationDTO;
 import com.diagbot.dto.RespDTO;
 import com.diagbot.facade.KlConceptFacade;
+import com.diagbot.vo.SearchCollectionConceptVO;
 import com.diagbot.vo.SearchConceptVO;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
@@ -28,7 +29,7 @@ import java.util.List;
 @RestController
 @RequestMapping("/klDisease")
 @SuppressWarnings("unchecked")
-@Api(value = "诊断依据相关的类型术语相关API", tags = { "诊断依据相关的类型术语相关API" })
+@Api(value = "诊断依据相关的类型术语相关API", tags = {"诊断依据相关的类型术语相关API"})
 public class KlDiseaseController {
 
     @Autowired
@@ -45,4 +46,38 @@ public class KlDiseaseController {
         return RespDTO.onSuc(getAllForRelationDTOS);
     }
 
+    @ApiOperation(value = "术语集合新增[by:kongwz]",
+            notes = "name: 查询术语的名称<br>" +
+                    "libType: 查询术语的词性<br>" +
+                    "excludedConceptIds: 需要排除的概念id集合")
+    @PostMapping("/addConceptClass")
+    @SysLogger("addConceptClass")
+    public RespDTO<List<GetAllForRelationDTO>> addConceptClass(@Valid @RequestBody SearchConceptVO searchConceptVO) {
+        List<GetAllForRelationDTO> getAllForRelationDTOS = klConceptFacade.addConceptClass(searchConceptVO);
+        return RespDTO.onSuc(getAllForRelationDTOS);
+    }
+
+    @ApiOperation(value = "规则维护术语查询[by:kongwz]",
+            notes = "name: 查询术语的名称<br>" +
+                    "libType: 查询术语的词性<br>" +
+                    "excludedConceptIds: 需要排除的概念id集合")
+    @PostMapping("/searchConceptRuleClass")
+    @SysLogger("searchConceptRuleClass")
+    public RespDTO<List<GetAllForRelationDTO>> searchConceptRuleClass(@Valid @RequestBody SearchConceptVO searchConceptVO) {
+        List<GetAllForRelationDTO> getAllForRelationDTOS = klConceptFacade.searchConceptRuleClass(searchConceptVO);
+        return RespDTO.onSuc(getAllForRelationDTOS);
+    }
+
+    @ApiOperation(value = "在集合业务中，搜索术语[by:kongwz]",
+            notes = "names: 搜索关键词集合<br>" +
+                    "libType: 查询术语的词性<br>" +
+                    "excludedConceptIds: 需要排除的概念id集合<br>" +
+                    "logicalOperator: 逻辑运算符 0:and 1:or")
+    @PostMapping("/searchCollectionConceptVO")
+    @SysLogger("searchCollectionConceptVO")
+    public RespDTO<List<GetAllForRelationDTO>> searchCollectionConcept(@Valid @RequestBody SearchCollectionConceptVO searchCollectionConceptVO) {
+        List<GetAllForRelationDTO> getAllForRelationDTOS = klConceptFacade.searchCollectionConceptFac(searchCollectionConceptVO);
+        return RespDTO.onSuc(getAllForRelationDTOS);
+    }
+
 }

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

@@ -9,6 +9,7 @@ import com.diagbot.facade.KlConceptFacade;
 import com.diagbot.facade.MedRetrievalFacade;
 import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.FilterVO;
+import com.diagbot.vo.IndexByApprovalVO;
 import com.diagbot.vo.KllisDetailVO;
 import com.diagbot.vo.RetrievalVO;
 import com.diagbot.vo.StaticKnowledgeIndexVO;
@@ -85,4 +86,16 @@ public class RetrievalController {
         List<IndexBatchDTO> data = klConceptFacade.filter(filterVO);
         return RespDTO.onSuc(data);
     }
+
+    /**
+     * @param indexByApprovalVO
+     * @return
+     */
+    @ApiOperation(value = "术语关联医学术语检索[zhaops]",
+            notes = "approvalList： 国药准字列表<br>")
+    @PostMapping("/indexByApproval")
+    public RespDTO<List<IndexBatchDTO>> indexByApproval(@Valid @RequestBody IndexByApprovalVO indexByApprovalVO) {
+        List<IndexBatchDTO> data = klConceptFacade.indexByApproval(indexByApprovalVO);
+        return RespDTO.onSuc(data);
+    }
 }

src/main/resources/mapper/KlDiagnoseRecordDetailMapper.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.diagbot.mapper.KlDiagnoseRecordDetailMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.KlDiagnoseRecordDetail">
+        <id column="id" property="id" />
+        <result column="is_deleted" property="isDeleted" />
+        <result column="gmt_create" property="gmtCreate" />
+        <result column="gmt_modified" property="gmtModified" />
+        <result column="creator" property="creator" />
+        <result column="modifier" property="modifier" />
+        <result column="diagnose_record_id" property="diagnoseRecordId" />
+        <result column="concept_id" property="conceptId" />
+        <result column="order_no" property="orderNo" />
+        <result column="remark" property="remark" />
+    </resultMap>
+
+</mapper>

src/main/resources/mapper/KlDiagnoseRecordMapper.xml

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.diagbot.mapper.KlDiagnoseRecordMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.KlDiagnoseRecord">
+        <id column="id" property="id"/>
+        <result column="is_deleted" property="isDeleted"/>
+        <result column="gmt_create" property="gmtCreate"/>
+        <result column="gmt_modified" property="gmtModified"/>
+        <result column="creator" property="creator"/>
+        <result column="modifier" property="modifier"/>
+        <result column="diagnose_id" property="diagnoseId"/>
+        <result column="type" property="type"/>
+        <result column="code" property="code"/>
+        <result column="rule" property="rule"/>
+        <result column="desc" property="description"/>
+        <result column="eq_operator" property="eqValue"/>
+        <result column="max_value" property="maxValue"/>
+        <result column="max_operator" property="maxOperator"/>
+        <result column="min_value" property="minValue"/>
+        <result column="min_operator" property="minOperator"/>
+        <result column="unit" property="unit"/>
+        <result column="order_no" property="orderNo"/>
+        <result column="remark" property="remark"/>
+    </resultMap>
+
+    <select id="getDiagnoseRecord" resultType="com.diagbot.dto.DiagnoseRecordDTO">
+		SELECT
+			k3.lib_name AS diseaseName,
+			kdr.type AS type,
+			kdr.`code` AS orderNo,
+			IFNULL(k2.rule, kdr.rule) AS rule,
+			kdr.description AS relation,
+			kdr.eq_value AS eq,
+			kdr.max_value AS max,
+			kdr.max_operator AS maxSymbol,
+			kdr.min_value AS min,
+			kdr.min_operator AS minSymbol,
+			kdr.unit AS unit
+		FROM
+			kl_diagnose_record kdr
+			LEFT JOIN (
+			SELECT
+			k1.diagnose_record_id,
+			GROUP_CONCAT(
+			k1.lib_name
+			ORDER BY
+			order_no SEPARATOR '#'
+			) rule
+			FROM
+			(
+			SELECT
+			kdrd.diagnose_record_id,
+			kdrd.concept_id,
+			kc.lib_name,
+			kdrd.order_no
+			FROM
+			`kl_diagnose_record_detail` kdrd
+			LEFT JOIN kl_concept kc ON kdrd.concept_id = kc.id
+			WHERE
+			kc.is_deleted = 'N'
+			AND kc.`status` = 1
+			) k1
+			GROUP BY
+			k1.diagnose_record_id
+			) k2 ON kdr.id = k2.diagnose_record_id
+			LEFT JOIN kl_diagnose kd ON kdr.diagnose_id = kd.id
+			LEFT JOIN kl_concept k3 ON kd.concept_id = k3.id
+		WHERE
+			k3.is_deleted = 'N'
+		  AND k3.`status` = 1
+		  AND kd. STATUS = 1
+		ORDER BY
+			kd.gmt_modified,
+			kd.id,
+			kdr.order_no
+    </select>
+
+</mapper>

src/main/resources/mapper/KlLibraryInfoMapper.xml

@@ -37,7 +37,7 @@
         FROM
         (SELECT DISTINCT
         a.concept_id as id,
-        a.name,
+        c.lib_name AS name,
         a.is_concept as isConcept
         <if test="type!=null and type==100">,
             b.icd10_code as code
@@ -53,6 +53,8 @@
         </if>
         FROM
         kl_library_info a
+        LEFT JOIN kl_concept c
+        ON a.concept_id = c.id
         <if test="type!=null and type==100">
             left join kl_disease b
             on b.is_deleted = 'N'
@@ -74,6 +76,7 @@
             and a.concept_id = b.concept_id
         </if>
         WHERE a.is_deleted = "N"
+        AND c.status = 1
         <if test="type!=null">
             AND a.type_id = #{type}
         </if>
@@ -102,7 +105,7 @@
         FROM
         (SELECT DISTINCT
         a.concept_id as id,
-        a.name,
+        c.lib_name AS name,
         a.is_concept as isConcept
         <if test="type!=null and type==100">,
             b.icd10_code as code
@@ -118,6 +121,8 @@
         </if>
         FROM
         kl_library_info a
+        LEFT JOIN kl_concept c
+        ON a.concept_id = c.id
         <if test="type!=null and type==100">
             left join kl_disease b
             on b.is_deleted = 'N'
@@ -139,6 +144,7 @@
             and a.concept_id = b.concept_id
         </if>
         WHERE a.is_deleted = "N"
+        AND c.status = 1
         <if test="type!=null">
             AND a.type_id = #{type}
         </if>

src/main/resources/mapper/KlRuleMapper.xml

@@ -235,10 +235,13 @@
             tt2.lib_name base_name,
             xx2.NAME base_type,
             CASE
-                when tt1.type = '4' and xx2.`name` in ('药品通用名','药品化学物质类别','药品治疗学类别','药品药理学类别','药品解剖学类别') then '药物过敏原'
-                when tt1.type = '1' and xx2.`name` in ('药品通用名','药品化学物质类别','药品治疗学类别','药品药理学类别','药品解剖学类别') then '服用药品'
+                when tt1.type = '1' then '等于术语'
+                when tt1.type = '2' then '比较'
+                when tt1.type = '3' then '不等于术语'
+                when tt1.type = '4' then '过敏'
                 when tt1.type = '5' then '开单项互斥'
-                else xx2.name
+                when tt1.type = '6' then '正则'
+                else '错误类型'
 			end taboo_type,
             tt1.eq_value,
             tt1.min_value,
@@ -294,7 +297,7 @@
         LEFT JOIN kl_concept tt2 ON tt2.is_deleted = 'N'
         AND tt2.`status` = 1
         AND tt1.base_id = tt2.id
-        LEFT JOIN kl_lexicon xx2 ON tt2.lib_type = xx2. CODE
+        LEFT JOIN kl_lexicon xx2 ON tt2.lib_type = xx2.CODE
         ORDER BY par_name, rule_id
     </select>
 

src/test/java/com/diagbot/CodeGeneration.java

@@ -56,7 +56,7 @@ public class CodeGeneration {
         StrategyConfig strategy = new StrategyConfig();
         // strategy.setTablePrefix(new String[] { "demo_" });// 此处可以修改为您的表前缀
         strategy.setNaming(NamingStrategy.underline_to_camel);// 表名生成策略
-        strategy.setInclude("kl_rule_condition"); // 需要生成的表
+        strategy.setInclude("kl_diagnose_record", "kl_diagnose_record_detail"); // 需要生成的表
 
         strategy.setSuperServiceClass(null);
         strategy.setSuperServiceImplClass(null);