Merge branch 'develop' into his/hz7y

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='诊断依据记录明细表';

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/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/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/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,8 @@ public enum RedisEnum implements KeyedNamed {
     hospitalId_(14, "hospitalId_"),
     deptPush(15, "deptPush"),
     frequency(20, "frequency"),
-    msg(21, "msg");
+    msg(21, "msg"),
+    vteAdvice(22, "vteAdvice:");
 
     @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/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();
-
     }
 
     /**
@@ -120,6 +121,25 @@ public class CacheFacade {
         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()));
+            }
+        }
+    }
+
     /**
      * 重新加载大数据缓存
      *

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

@@ -162,6 +162,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);

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

@@ -4,25 +4,13 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.diagbot.dto.GetAllForRelationDTO;
 import com.diagbot.dto.IndexBatchDTO;
 import com.diagbot.dto.KllisDetailDTO;
-import com.diagbot.entity.KlConcept;
-import com.diagbot.entity.KlDisease;
-import com.diagbot.entity.KlLibraryInfo;
-import com.diagbot.entity.KlOperation;
-import com.diagbot.entity.TcmDisease;
-import com.diagbot.entity.TcmSyndrome;
-import com.diagbot.enums.ConceptTypeEnum;
-import com.diagbot.enums.IsDeleteEnum;
-import com.diagbot.enums.LexiconEnum;
-import com.diagbot.enums.MatchSourceEnum;
-import com.diagbot.enums.StatusEnum;
+import com.diagbot.entity.*;
+import com.diagbot.enums.*;
 import com.diagbot.service.impl.KlConceptServiceImpl;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ListUtil;
 import com.diagbot.util.StringUtil;
-import com.diagbot.vo.ConceptVO;
-import com.diagbot.vo.FilterVO;
-import com.diagbot.vo.KllisDetailVO;
-import com.diagbot.vo.SearchConceptVO;
+import com.diagbot.vo.*;
 import com.google.common.collect.Lists;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -392,6 +380,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 +413,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 +425,8 @@ public class KlConceptFacade extends KlConceptServiceImpl {
                     return getAllForRelationDTO;
                 }).collect(Collectors.toList());
             }
+
+
         }
         return getAllForRelationDTOS;
     }
@@ -423,4 +436,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/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<>();

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

@@ -1,14 +1,21 @@
 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.entity.KlDiagnoseRecord;
+import com.diagbot.entity.KlDiagnoseRecordDetail;
 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.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 +39,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 +61,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 +82,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();
@@ -152,6 +172,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 +250,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 +301,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 +334,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 +381,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)) {
@@ -429,6 +486,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 +620,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/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/mapper/KlConceptMapper.java

@@ -1,13 +1,12 @@
 package com.diagbot.mapper;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.diagbot.dto.GetAllForRelationDTO;
 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;
 
@@ -26,4 +25,10 @@ public interface KlConceptMapper extends BaseMapper<KlConcept> {
     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

@@ -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/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,6 +10,7 @@ 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;
@@ -17,11 +19,17 @@ 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 +50,8 @@ public class OtherTipProcess {
     LisRule lisRule;
     @Autowired
     PacsRule pacsRule;
+    @Autowired
+    RedisUtil redisUtil;
 
     /**
      * 处理业务——化验
@@ -125,6 +135,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

@@ -9,6 +9,7 @@ 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 +19,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 +28,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 +36,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 +250,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);
@@ -285,7 +288,7 @@ public class CommonRule {
             if (CoreUtil.getMapFlag(lisMap)) {
                 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.setConType(conType);
@@ -345,76 +348,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 +471,7 @@ public class CommonRule {
     }
 
     /**
-     * 24小时重复开单入口
+     * 24小时重复开单入口——与开单项比较
      *
      * @param billMsgList
      * @param itemList
@@ -449,10 +479,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 +493,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 +516,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 +656,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/service/KlConceptService.java

@@ -1,13 +1,12 @@
 package com.diagbot.service;
 
 import com.baomidou.mybatisplus.extension.service.IService;
+import com.diagbot.dto.GetAllForRelationDTO;
 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;
 
@@ -26,4 +25,14 @@ public interface KlConceptService extends IService<KlConcept> {
     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,14 @@ 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.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;
@@ -41,4 +40,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/CoreUtil.java

@@ -2,7 +2,6 @@ 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.RuleBaseDTO;
 import com.diagbot.enums.CommonEnum;
 import com.diagbot.enums.LexiconEnum;
@@ -357,17 +356,21 @@ public class CoreUtil {
                 double value = lis.getValue();
                 flag = compareNum(ruleBaseDTO, value);
                 if (flag) {
+                    // 获取化验单位拼接
+                    String unitsJoint = getJointUnits(lis);
                     if (StringUtil.isNotBlank(lis.getName()) && lis.getName().equals(lis.getDetailName())) {
                         if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getDetailName() + "结果" + lis.getResult());
+                            map.put("msg", lis.getDetailName() + "结果" + lis.getResult() + unitsJoint);
                         } else {
-                            map.put("msg", lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())));
+                            map.put("msg", lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())) + unitsJoint);
                         }
                     } else {
                         if (StringUtil.isNotBlank(lis.getResult())) {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + lis.getResult());
+                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + lis.getResult() + unitsJoint);
                         } else {
-                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())));
+                            // 获取化验单位拼接
+                            unitsJoint = getJointUnits(lis);
+                            map.put("msg", lis.getName() + lis.getDetailName() + "结果" + subZeroAndDot(String.valueOf(lis.getValue())) + unitsJoint);
                         }
                     }
                 }
@@ -377,6 +380,46 @@ public class CoreUtil {
         return map;
     }
 
+    /**
+     * 化验返回单位
+     *
+     * @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 +452,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);
                             }
                         }
                     }
@@ -1041,7 +1088,7 @@ public class CoreUtil {
                 if (StringUtil.isNotBlank(value1)) {
                     unionKey += value1;
                 }
-                unionKey += "*****";
+                unionKey += CommonEnum.splitSymbol.getName();
                 if (StringUtil.isNotBlank(value2)) {
                     unionKey += value2;
                 }
@@ -1203,15 +1250,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 +1269,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 +1325,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

@@ -31,6 +31,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(), "通用" + "_" + "默认提示语");
@@ -59,6 +60,7 @@ public class MsgNewUtil {
         // 放到最后统一替换【多处匹配】
         msg = msg.replaceAll("\\[匹配内容]", content);
         msg = msg.replaceAll("\\[开单名称]", orderName);
+        msg = msg.replaceAll("\\[项目名称]", structName);
         billMsg.setMsg(msg);
         billMsg.setOrderName(orderName);
         billMsg.setOrderStandName(orderStandName);

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/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/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/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/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);