自动化测试

cdssman-service/src/main/java/com/diagbot/aggregate/RuleTestAggregate.java

@@ -13,13 +13,12 @@ import com.diagbot.entity.ResultInfo;
 import com.diagbot.entity.ResultOtherLis;
 import com.diagbot.entity.ResultOtherPacs;
 import com.diagbot.entity.ResultOtherTransfusion;
-import com.diagbot.entity.node.BillItem;
+import com.diagbot.entity.ResultRule;
 import com.diagbot.entity.node.LisCritical;
 import com.diagbot.entity.node.LisRemind;
 import com.diagbot.entity.node.MedRegName;
 import com.diagbot.entity.node.PacsCritical;
 import com.diagbot.entity.node.PacsRemind;
-import com.diagbot.entity.node.TransfusionRemind;
 import com.diagbot.entity.node.TransfusionSuggest;
 import com.diagbot.entity.node.YiBaoOperationName;
 import com.diagbot.enums.IsDeleteEnum;
@@ -48,6 +47,7 @@ import com.diagbot.service.ResultInfoService;
 import com.diagbot.service.ResultOtherLisService;
 import com.diagbot.service.ResultOtherPacsService;
 import com.diagbot.service.ResultOtherTransfusionService;
+import com.diagbot.service.ResultRuleService;
 import com.diagbot.util.BeanUtil;
 import com.diagbot.util.FastJsonUtils;
 import com.diagbot.util.ListUtil;
@@ -87,6 +87,9 @@ public class RuleTestAggregate {
     @Qualifier("resultBillServiceImpl")
     private ResultBillService resultBillService;
     @Autowired
+    @Qualifier("resultRuleServiceImpl")
+    private ResultRuleService resultRuleService;
+    @Autowired
     @Qualifier("resultInfoServiceImpl")
     private ResultInfoService resultInfoService;
     @Autowired
@@ -189,14 +192,14 @@ public class RuleTestAggregate {
         Long hospitalId = billRuleVO.getHospitalId();
 
         //生成测试规则
-        List<ResultBill> resultList = medRuleConvertFacade.billConvert(hospitalId, 1);
+        List<ResultRule> resultList = medRuleConvertFacade.billConvert(hospitalId, 1L);
         if (ListUtil.isEmpty(resultList)) {
             return true;
         }
         //远程调用推理
-        List<ResultBill> saveList = callBill(resultList, hospitalId);
+        List<ResultRule> saveList = callBill(resultList, hospitalId);
         //保存测试结果
-        saveResultBill(saveList, billRuleVO);
+        saveResultRule(saveList, billRuleVO);
         return true;
     }
 
@@ -226,14 +229,14 @@ public class RuleTestAggregate {
         Long hospitalId = billRuleVO.getHospitalId();
 
         //生成测试规则
-        List<ResultBill> resultList = medRuleConvertFacade.billConvert(hospitalId, 2);
+        List<ResultRule> resultList = medRuleConvertFacade.billConvert(hospitalId, billRuleVO.getCaseId());
         if (ListUtil.isEmpty(resultList)) {
             return true;
         }
         //远程调用推理
-        List<ResultBill> saveList = callBill(resultList, hospitalId);
+        List<ResultRule> saveList = callBill(resultList, hospitalId);
         //保存测试结果
-        saveResultBill(saveList, billRuleVO);
+        saveResultRule(saveList, billRuleVO);
         return true;
     }
 
@@ -479,49 +482,50 @@ public class RuleTestAggregate {
      * @param hospitalId
      * @return
      */
-    public List<ResultBill> callBill(List<ResultBill> list, Long hospitalId) {
-        List<ResultBill> retList = Lists.newLinkedList();
+    public List<ResultRule> callBill(List<ResultRule> list, Long hospitalId) {
+        List<ResultRule> retList = Lists.newLinkedList();
         if (ListUtil.isEmpty(list)) {
             return retList;
         }
-        for (ResultBill resultBill : list) {
-            if (resultBill.getSuccess() != null
-                    && resultBill.getSuccess().equals(0)) {
-                retList.add(resultBill);
+        for (ResultRule result : list) {
+            if (result.getSuccess() != null
+                    && result.getSuccess().equals(0)) {
+                retList.add(result);
                 continue;
             }
             //IndicationPushVO indicationPushVO = searchDataFacade.createBillVO(resultBill);
-            IndicationPushVO indicationPushVO = medSearchDataFacade.createBillVO(resultBill);
+            IndicationPushVO indicationPushVO = medSearchDataFacade.createBillVO(result);
             indicationPushVO.setHospitalId(hospitalId);
 
-            resultBill.setInputParams(FastJsonUtils.getBeanToJson(indicationPushVO));
+            result.setInputParams(FastJsonUtils.getBeanToJson(indicationPushVO));
 
             RespDTO<IndicationDTO> respDTO = cdssCoreClient.indication(indicationPushVO);
             if (RespDTOUtil.respIsOK(respDTO)) {
                 IndicationDTO data = respDTO.data;
+                result.setOutputParams(FastJsonUtils.getBeanToJson(respDTO.data));
                 List<BillMsg> billMsgList = data.getBillMsgList();
                 if (ListUtil.isEmpty(billMsgList)) {
-                    resultBill.setSuccess(0);
-                    resultBill.setMessage("提醒信息未出现");
-                    retList.add(resultBill);
+                    result.setSuccess(0);
+                    result.setMessage("提醒信息未出现");
+                    retList.add(result);
                 } else {
                     for (BillMsg billMsg : billMsgList) {
-                        ResultBill saveResultBill = new ResultBill();
-                        BeanUtil.copyProperties(resultBill, saveResultBill);
-                        saveResultBill.setOutput(billMsg.getMsg());
-                        if (saveResultBill.getOutput().equals(saveResultBill.getExpectedOutput())) {
-                            saveResultBill.setSuccess(1);
+                        ResultRule saveResult = new ResultRule();
+                        BeanUtil.copyProperties(result, saveResult);
+                        saveResult.setOutput(billMsg.getMsg());
+                        if (saveResult.getOutput().equals(saveResult.getExpectedOutput())) {
+                            saveResult.setSuccess(1);
                         } else {
-                            saveResultBill.setSuccess(0);
-                            saveResultBill.setMessage("提示内容与预期不符");
+                            saveResult.setSuccess(0);
+                            saveResult.setMessage("提示内容与预期不符");
                         }
-                        retList.add(saveResultBill);
+                        retList.add(saveResult);
                     }
                 }
             } else {
-                resultBill.setSuccess(0);
-                resultBill.setMessage("远程调用推理接口失败");
-                retList.add(resultBill);
+                result.setSuccess(0);
+                result.setMessage("远程调用推理接口失败");
+                retList.add(result);
             }
         }
         return retList;
@@ -865,7 +869,7 @@ public class RuleTestAggregate {
      * @return
      */
     @Transactional
-    public Boolean saveResultBill(List<ResultBill> list, BillRuleVO billRuleVO) {
+    public Boolean saveResultRule(List<ResultRule> list, BillRuleVO billRuleVO) {
         Date now = new Date();
         Integer totleNum = list.size();
         Integer successNum = list.stream().filter(i -> i.getSuccess().equals(1)).collect(Collectors.toList()).size();
@@ -891,14 +895,13 @@ public class RuleTestAggregate {
         resultBillQueryWrapper.eq("result_id", resultInfo.getId());
         resultBillService.remove(resultBillQueryWrapper);
 
-        for (ResultBill resultBill : list) {
-            resultBill.setBillType(billRuleVO.getBillType());
-            resultBill.setGmtCreate(now);
-            resultBill.setGmtModified(now);
-            resultBill.setResultId(resultInfo.getId());
+        for (ResultRule resultRule : list) {
+            resultRule.setGmtCreate(now);
+            resultRule.setGmtModified(now);
+            resultRule.setResultId(resultInfo.getId());
         }
 
-        resultBillService.saveOrUpdateBatch(list);
+        resultRuleService.saveOrUpdateBatch(list);
         return true;
     }
 

cdssman-service/src/main/java/com/diagbot/entity/ResultRule.java

@@ -0,0 +1,478 @@
+package com.diagbot.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * <p>
+ * 
+ * </p>
+ *
+ * @author zhaops
+ * @since 2021-03-09
+ */
+@TableName("test_result_rule")
+public class ResultRule 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 resultId;
+
+    /**
+     * 规则类型（1：开单-通用，2：开单-输血，3：危急值-检验，4：危急值-检查，5：高危药品，6：高危手术，7：其他值提醒-检验，8-其他值提醒-检查，9-其他值提醒-输血，10：正常项目重复开立）
+     */
+    private Integer ruleType;
+
+    /**
+     * 开单项类型（编码）
+     */
+    private Integer ruleLibType;
+
+    /**
+     * 开单项类型（名称）
+     */
+    private String ruleLibTypeName;
+
+    /**
+     * 开单项名称
+     */
+    private String ruleLibName;
+
+    /**
+     * 开单项名称（医院端）
+     */
+    private String ruleHisName;
+
+    /**
+     * 开单项名称-细项（医院端）
+     */
+    private String ruleHisDetailName;
+
+    /**
+     * 是否有子条件（0：无，1：有）
+     */
+    private Integer hasSubCond;
+
+    /**
+     * 规则组别
+     */
+    private Integer groupType;
+
+    /**
+     * 基础规则类型(1:开单外等于术语本身;2:开单外存在比较;3:开单外不等于术语本身;4:过敏原;5:开单项;6:检查结果正则表达式)
+     */
+    private Integer ruleBaseType;
+
+    /**
+     * 禁忌项类型（编码）
+     */
+    private Integer ruleBaseLibType;
+
+    /**
+     * 禁忌项类型（名称）
+     */
+    private String ruleBaseLibTypeName;
+
+    /**
+     * 禁忌项名称
+     */
+    private String ruleBaseLibName;
+
+    /**
+     * 禁忌项名称（医院端）
+     */
+    private String ruleBaseHisName;
+
+    /**
+     * 禁忌项名称-细项（医院端）
+     */
+    private String ruleBaseHisDetailName;
+
+    /**
+     * 禁忌项参考值（最大值）
+     */
+    private BigDecimal ruleBaseMaxValue;
+
+    /**
+     * 禁忌项参考值（最小值）
+     */
+    private BigDecimal ruleBaseMinValue;
+
+    /**
+     * 禁忌项单位
+     */
+    private String ruleBaseUnit;
+
+    /**
+     * 禁忌项输入值（文本/数值）
+     */
+    private String ruleBaseInputValue;
+
+    /**
+     * 参考值（参考范围拼接/药品分类保存）
+     */
+    private String referenceValue;
+
+    /**
+     * 实际输出结果（提醒文本）
+     */
+    private String output;
+
+    /**
+     * 期望输出结果（提醒文本）
+     */
+    private String expectedOutput;
+
+    /**
+     * 成功标志（1：成功，0：失败）
+     */
+    private Integer success;
+
+    /**
+     * 提示信息（异常提醒）
+     */
+    private String message;
+
+    /**
+     * 模拟入参
+     */
+    private String inputParams;
+
+    /**
+     * 模拟出参
+     */
+    private String outputParams;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getIsDeleted() {
+        return isDeleted;
+    }
+
+    public void setIsDeleted(String isDeleted) {
+        this.isDeleted = isDeleted;
+    }
+
+    public Date getGmtCreate() {
+        return gmtCreate;
+    }
+
+    public void setGmtCreate(Date gmtCreate) {
+        this.gmtCreate = gmtCreate;
+    }
+
+    public Date getGmtModified() {
+        return gmtModified;
+    }
+
+    public void setGmtModified(Date gmtModified) {
+        this.gmtModified = gmtModified;
+    }
+
+    public String getCreator() {
+        return creator;
+    }
+
+    public void setCreator(String creator) {
+        this.creator = creator;
+    }
+
+    public String getModifier() {
+        return modifier;
+    }
+
+    public void setModifier(String modifier) {
+        this.modifier = modifier;
+    }
+
+    public Long getResultId() {
+        return resultId;
+    }
+
+    public void setResultId(Long resultId) {
+        this.resultId = resultId;
+    }
+
+    public Integer getRuleType() {
+        return ruleType;
+    }
+
+    public void setRuleType(Integer ruleType) {
+        this.ruleType = ruleType;
+    }
+
+    public Integer getRuleLibType() {
+        return ruleLibType;
+    }
+
+    public void setRuleLibType(Integer ruleLibType) {
+        this.ruleLibType = ruleLibType;
+    }
+
+    public String getRuleLibTypeName() {
+        return ruleLibTypeName;
+    }
+
+    public void setRuleLibTypeName(String ruleLibTypeName) {
+        this.ruleLibTypeName = ruleLibTypeName;
+    }
+
+    public String getRuleLibName() {
+        return ruleLibName;
+    }
+
+    public void setRuleLibName(String ruleLibName) {
+        this.ruleLibName = ruleLibName;
+    }
+
+    public String getRuleHisName() {
+        return ruleHisName;
+    }
+
+    public void setRuleHisName(String ruleHisName) {
+        this.ruleHisName = ruleHisName;
+    }
+
+    public String getRuleHisDetailName() {
+        return ruleHisDetailName;
+    }
+
+    public void setRuleHisDetailName(String ruleHisDetailName) {
+        this.ruleHisDetailName = ruleHisDetailName;
+    }
+
+    public Integer getHasSubCond() {
+        return hasSubCond;
+    }
+
+    public void setHasSubCond(Integer hasSubCond) {
+        this.hasSubCond = hasSubCond;
+    }
+
+    public Integer getGroupType() {
+        return groupType;
+    }
+
+    public void setGroupType(Integer groupType) {
+        this.groupType = groupType;
+    }
+
+    public Integer getRuleBaseType() {
+        return ruleBaseType;
+    }
+
+    public void setRuleBaseType(Integer ruleBaseType) {
+        this.ruleBaseType = ruleBaseType;
+    }
+
+    public Integer getRuleBaseLibType() {
+        return ruleBaseLibType;
+    }
+
+    public void setRuleBaseLibType(Integer ruleBaseLibType) {
+        this.ruleBaseLibType = ruleBaseLibType;
+    }
+
+    public String getRuleBaseLibTypeName() {
+        return ruleBaseLibTypeName;
+    }
+
+    public void setRuleBaseLibTypeName(String ruleBaseLibTypeName) {
+        this.ruleBaseLibTypeName = ruleBaseLibTypeName;
+    }
+
+    public String getRuleBaseLibName() {
+        return ruleBaseLibName;
+    }
+
+    public void setRuleBaseLibName(String ruleBaseLibName) {
+        this.ruleBaseLibName = ruleBaseLibName;
+    }
+
+    public String getRuleBaseHisName() {
+        return ruleBaseHisName;
+    }
+
+    public void setRuleBaseHisName(String ruleBaseHisName) {
+        this.ruleBaseHisName = ruleBaseHisName;
+    }
+
+    public String getRuleBaseHisDetailName() {
+        return ruleBaseHisDetailName;
+    }
+
+    public void setRuleBaseHisDetailName(String ruleBaseHisDetailName) {
+        this.ruleBaseHisDetailName = ruleBaseHisDetailName;
+    }
+
+    public BigDecimal getRuleBaseMaxValue() {
+        return ruleBaseMaxValue;
+    }
+
+    public void setRuleBaseMaxValue(BigDecimal ruleBaseMaxValue) {
+        this.ruleBaseMaxValue = ruleBaseMaxValue;
+    }
+
+    public BigDecimal getRuleBaseMinValue() {
+        return ruleBaseMinValue;
+    }
+
+    public void setRuleBaseMinValue(BigDecimal ruleBaseMinValue) {
+        this.ruleBaseMinValue = ruleBaseMinValue;
+    }
+
+    public String getRuleBaseUnit() {
+        return ruleBaseUnit;
+    }
+
+    public void setRuleBaseUnit(String ruleBaseUnit) {
+        this.ruleBaseUnit = ruleBaseUnit;
+    }
+
+    public String getRuleBaseInputValue() {
+        return ruleBaseInputValue;
+    }
+
+    public void setRuleBaseInputValue(String ruleBaseInputValue) {
+        this.ruleBaseInputValue = ruleBaseInputValue;
+    }
+
+    public String getReferenceValue() {
+        return referenceValue;
+    }
+
+    public void setReferenceValue(String referenceValue) {
+        this.referenceValue = referenceValue;
+    }
+
+    public String getOutput() {
+        return output;
+    }
+
+    public void setOutput(String output) {
+        this.output = output;
+    }
+
+    public String getExpectedOutput() {
+        return expectedOutput;
+    }
+
+    public void setExpectedOutput(String expectedOutput) {
+        this.expectedOutput = expectedOutput;
+    }
+
+    public Integer getSuccess() {
+        return success;
+    }
+
+    public void setSuccess(Integer success) {
+        this.success = success;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public String getInputParams() {
+        return inputParams;
+    }
+
+    public void setInputParams(String inputParams) {
+        this.inputParams = inputParams;
+    }
+
+    public String getOutputParams() {
+        return outputParams;
+    }
+
+    public void setOutputParams(String outputParams) {
+        this.outputParams = outputParams;
+    }
+
+    @Override
+    public String toString() {
+        return "ResultRule{" +
+                "id=" + id +
+                ", isDeleted=" + isDeleted +
+                ", gmtCreate=" + gmtCreate +
+                ", gmtModified=" + gmtModified +
+                ", creator=" + creator +
+                ", modifier=" + modifier +
+                ", resultId=" + resultId +
+                ", ruleType=" + ruleType +
+                ", ruleLibType=" + ruleLibType +
+                ", ruleLibTypeName=" + ruleLibTypeName +
+                ", ruleLibName=" + ruleLibName +
+                ", ruleHisName=" + ruleHisName +
+                ", ruleHisDetailName=" + ruleHisDetailName +
+                ", hasSubCond=" + hasSubCond +
+                ", groupType=" + groupType +
+                ", ruleBaseType=" + ruleBaseType +
+                ", ruleBaseLibType=" + ruleBaseLibType +
+                ", ruleBaseLibTypeName=" + ruleBaseLibTypeName +
+                ", ruleBaseLibName=" + ruleBaseLibName +
+                ", ruleBaseHisName=" + ruleBaseHisName +
+                ", ruleBaseHisDetailName=" + ruleBaseHisDetailName +
+                ", ruleBaseMaxValue=" + ruleBaseMaxValue +
+                ", ruleBaseMinValue=" + ruleBaseMinValue +
+                ", ruleBaseUnit=" + ruleBaseUnit +
+                ", ruleBaseInputValue=" + ruleBaseInputValue +
+                ", referenceValue=" + referenceValue +
+                ", output=" + output +
+                ", expectedOutput=" + expectedOutput +
+                ", success=" + success +
+                ", message=" + message +
+                ", inputParams=" + inputParams +
+                ", outputParams=" + outputParams +
+                "}";
+    }
+}

cdssman-service/src/main/java/com/diagbot/facade/MedSearchDataFacade.java

@@ -3,7 +3,7 @@ package com.diagbot.facade;
 import com.diagbot.biz.push.entity.Item;
 import com.diagbot.biz.push.entity.Lis;
 import com.diagbot.biz.push.entity.Pacs;
-import com.diagbot.entity.ResultBill;
+import com.diagbot.entity.ResultRule;
 import com.diagbot.enums.LexiconEnum;
 import com.diagbot.enums.RuleBaseTypeEnum;
 import com.diagbot.util.StringUtil;
@@ -22,151 +22,154 @@ public class MedSearchDataFacade {
     /**
      * 生成开单合理性入参
      *
-     * @param resultBill
+     * @param result
      * @return
      */
-    public IndicationPushVO createBillVO(ResultBill resultBill) {
+    public IndicationPushVO createBillVO(ResultRule result) {
         IndicationPushVO indicationPushVO = new IndicationPushVO();
         indicationPushVO.setAge("20");
         indicationPushVO.setSex(3);
         indicationPushVO.setRuleType("2");
 
         //开单项
-        if (resultBill.getBillItemTypeCode().equals(LexiconEnum.LisName.getKey())) {
+        if (result.getRuleLibType().equals(LexiconEnum.LisName.getKey())) {
             //检验开单项
             Lis lis = new Lis();
-            lis.setName(resultBill.getBillItemHisName());
-            lis.setUniqueName(resultBill.getBillItemName());
+            lis.setName(result.getRuleHisName());
+            lis.setUniqueName(result.getRuleLibName());
             indicationPushVO.getLisOrder().add(lis);
         }
-        if (resultBill.getBillItemTypeCode().equals(LexiconEnum.PacsName.getKey())
-                || resultBill.getBillItemTypeCode().equals(LexiconEnum.PacsSubName.getKey())) {
+        if (result.getRuleLibType().equals(LexiconEnum.PacsName.getKey())
+                || result.getRuleLibType().equals(LexiconEnum.PacsSubName.getKey())) {
             Pacs pacs = new Pacs();
-            pacs.setName(resultBill.getBillItemHisName());
-            pacs.setUniqueName(resultBill.getBillItemName());
+            pacs.setName(result.getRuleHisName());
+            pacs.setUniqueName(result.getRuleLibName());
             indicationPushVO.getPacsOrder().add(pacs);
         }
-        if (resultBill.getBillItemTypeCode().equals(LexiconEnum.Operation.getKey())) {
+        if (result.getRuleLibType().equals(LexiconEnum.Operation.getKey())) {
             Item operation = new Item();
-            operation.setName(resultBill.getBillItemHisName());
-            operation.setUniqueName(resultBill.getBillItemName());
+            operation.setName(result.getRuleHisName());
+            operation.setUniqueName(result.getRuleLibName());
             indicationPushVO.getOperationOrder().add(operation);
         }
-        if (resultBill.getBillItemTypeCode().equals(LexiconEnum.Medicine.getKey())) {
+        if (result.getRuleLibType().equals(LexiconEnum.Medicine.getKey())) {
             Drug drug = new Drug();
-            drug.setName(resultBill.getBillItemHisName());
-            drug.setUniqueName(resultBill.getBillItemName());
+            drug.setName(result.getRuleHisName());
+            drug.setUniqueName(result.getRuleLibName());
             indicationPushVO.getDrugOrder().add(drug);
         }
-        if (resultBill.getBillItemTypeCode().equals(LexiconEnum.Transfusion.getKey())) {
+        if (result.getRuleLibType().equals(LexiconEnum.Transfusion.getKey())) {
             ItemExt itemExt = new ItemExt();
-            itemExt.setName(resultBill.getBillItemHisName());
-            itemExt.setUniqueName(resultBill.getBillItemName());
+            itemExt.setName(result.getRuleHisName());
+            itemExt.setUniqueName(result.getRuleLibName());
             indicationPushVO.getTransfusionOrder().add(itemExt);
         }
 
-        /**
-         * 100	疾病	1
-         * 101	药品通用名	1
-         * 101	药品通用名	4
-         * 103	症状	1
-         * 104	体格检查项目	2
-         * 105	体格检查结果	1
-         * 106	手术和操作	1
-         * 108	实验室检查子项目	2
-         * 109	辅助检查项目	5
-         * 112	辅助检查结果	1
-         * 116	性别	1
-         * 117	人群	1
-         * 119	其他过敏原	4
-         * 120	医疗器械及物品	1
-         * 301	药品化学物质类别	4
-         * 302	药品治疗学类别	4
-         * 303	药品药理学类别	4
-         * 410	年龄	2
-         */
-        if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Disease.getKey())) {
-            Item diag = new Item();
-            diag.setName(resultBill.getConflictItemHisName());
-            diag.setUniqueName(resultBill.getConflictItemName());
-            indicationPushVO.getDiag().add(diag);
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Medicine.getKey())) {
-            if (resultBill.getConflictType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+        if (result.getRuleBaseLibType().equals(LexiconEnum.Disease.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                Item diag = new Item();
+                diag.setName(result.getRuleBaseHisName());
+                diag.setUniqueName(result.getRuleBaseLibName());
+                indicationPushVO.getDiag().add(diag);
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Medicine.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
                 indicationPushVO.setSymptom(indicationPushVO.getSymptom() +
-                        (StringUtil.isNotBlank(resultBill.getConflictItemHisName())
-                                ? ("一直服用" + resultBill.getConflictItemHisName() + ",")
+                        (StringUtil.isNotBlank(result.getRuleBaseHisName())
+                                ? ("一直服用" + result.getRuleBaseHisName() + ",")
                                 : ""));
-            } else if (resultBill.getConflictType().equals(RuleBaseTypeEnum.Allergen.getKey())) {
+            } else if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Allergen.getKey())) {
                 indicationPushVO.setPasts(indicationPushVO.getPasts() +
-                        (StringUtil.isNotBlank(resultBill.getConflictItemHisName())
-                                ? ("对" + resultBill.getConflictItemHisName() + "过敏,")
+                        (StringUtil.isNotBlank(result.getRuleBaseHisName())
+                                ? ("对" + result.getRuleBaseHisName() + "过敏,")
                                 : ""));
             }
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Symptom.getKey())) {
-            indicationPushVO.setSymptom(indicationPushVO.getSymptom() + resultBill.getConflictItemName() + ",");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Vital.getKey())) {
-            indicationPushVO.setVital(resultBill.getConflictItemName() + resultBill.getInputValue()
-                    + (StringUtil.isNotBlank(resultBill.getUnit()) ? resultBill.getUnit() : "")
-                    + ",");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.VitalResult.getKey())) {
-            indicationPushVO.setVital(resultBill.getConflictItemName() + resultBill.getInputValue() + ",");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Operation.getKey())) {
-            Item operation = new Item();
-            operation.setName(resultBill.getConflictItemHisName());
-            operation.setUniqueName(resultBill.getConflictItemName());
-            indicationPushVO.getOperation().add(operation);
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.LisSubName.getKey())) {
-            Lis lis = new Lis();
-            lis.setName(resultBill.getConflictItemHisName());
-            lis.setDetailName(resultBill.getConflictItemHisDetailName());
-            lis.setUniqueName(resultBill.getConflictItemName());
-            lis.setUnits(resultBill.getUnit());
-            if (resultBill.getMinValue() != null || resultBill.getMaxValue() != null) {
-                lis.setValue(Double.valueOf(resultBill.getInputValue()));
-            } else {
-                lis.setOtherValue(resultBill.getInputValue());
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Symptom.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                indicationPushVO.setSymptom(indicationPushVO.getSymptom() + result.getRuleBaseLibName() + ",");
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Vital.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Compare.getKey())) {
+                indicationPushVO.setVital(result.getRuleBaseLibName() + result.getRuleBaseInputValue()
+                        + (StringUtil.isNotBlank(result.getRuleBaseUnit()) ? result.getRuleBaseUnit() : "")
+                        + ",");
             }
-            if (resultBill.getMaxValue() != null) {
-                lis.setMaxValue(resultBill.getMaxValue().doubleValue());
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.VitalResult.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                indicationPushVO.setVital(result.getRuleBaseLibName() + result.getRuleBaseInputValue() + ",");
             }
-            if (resultBill.getMinValue() != null) {
-                lis.setMinValue(resultBill.getMinValue().doubleValue());
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Operation.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                Item operation = new Item();
+                operation.setName(result.getRuleBaseHisName());
+                operation.setUniqueName(result.getRuleBaseLibName());
+                indicationPushVO.getOperation().add(operation);
             }
-            indicationPushVO.getLis().add(lis);
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.PacsName.getKey())) {
-            if (resultBill.getConflictType().equals(RuleBaseTypeEnum.BillItem.getKey())) {
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.LisSubName.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Compare.getKey())) {
+                Lis lis = new Lis();
+                lis.setName(result.getRuleBaseHisName());
+                lis.setDetailName(result.getRuleBaseHisDetailName());
+                lis.setUniqueName(result.getRuleBaseLibName());
+                lis.setUnits(result.getRuleBaseUnit());
+                if (result.getRuleBaseMinValue() != null || result.getRuleBaseMaxValue() != null) {
+                    lis.setValue(Double.valueOf(result.getRuleBaseInputValue()));
+                } else {
+                    lis.setOtherValue(result.getRuleBaseInputValue());
+                }
+                if (result.getRuleBaseMaxValue() != null) {
+                    lis.setMaxValue(result.getRuleBaseMaxValue().doubleValue());
+                }
+                if (result.getRuleBaseMinValue() != null) {
+                    lis.setMinValue(result.getRuleBaseMinValue().doubleValue());
+                }
+                indicationPushVO.getLis().add(lis);
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsName.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.BillItem.getKey())) {
                 Pacs pacs = new Pacs();
-                pacs.setName(resultBill.getConflictItemHisName());
-                pacs.setUniqueName(resultBill.getConflictItemName());
+                pacs.setName(result.getRuleBaseHisName());
+                pacs.setUniqueName(result.getRuleBaseLibName());
                 indicationPushVO.getPacsOrder().add(pacs);
             }
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.PacsResult.getKey())) {
-            Pacs pacs = new Pacs();
-            pacs.setDesc(resultBill.getConflictItemName());
-            pacs.setResult(resultBill.getConflictItemName());
-            indicationPushVO.getPacs().add(pacs);
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Gender.getKey())) {
-            if (resultBill.getConflictItemName().equals("男")) {
-                indicationPushVO.setSex(1);
-            } else if (resultBill.getConflictItemName().equals("女")) {
-                indicationPushVO.setSex(2);
-            } else {
-                indicationPushVO.setSex(3);
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.PacsResult.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                Pacs pacs = new Pacs();
+                pacs.setDesc(result.getRuleBaseLibName());
+                pacs.setResult(result.getRuleBaseLibName());
+                indicationPushVO.getPacs().add(pacs);
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Gender.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                if (result.getRuleBaseLibName().equals("男")) {
+                    indicationPushVO.setSex(1);
+                } else if (result.getRuleBaseLibName().equals("女")) {
+                    indicationPushVO.setSex(2);
+                } else {
+                    indicationPushVO.setSex(3);
+                }
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Group.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                indicationPushVO.setSymptom(indicationPushVO.getSymptom() +
+                        result.getRuleBaseLibName() +
+                        (result.getRuleBaseInputValue() != null ? result.getRuleBaseInputValue() : "") +
+                        (StringUtil.isNotBlank(result.getRuleBaseUnit()) ? result.getRuleBaseUnit() : "") +
+                        ",");
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Allergen.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Allergen.getKey())) {
+                indicationPushVO.setPasts(indicationPushVO.getPasts() + "对" + result.getRuleBaseLibName() + "过敏,");
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Device.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Eq.getKey())) {
+                indicationPushVO.setPasts(indicationPushVO.getPasts() + "有" + result.getRuleBaseLibName() + ",");
+            }
+        } else if (result.getRuleBaseLibType().equals(LexiconEnum.Age.getKey())) {
+            if (result.getRuleBaseType().equals(RuleBaseTypeEnum.Compare.getKey())) {
+                indicationPushVO.setAge(result.getRuleBaseInputValue());
             }
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Group.getKey())) {
-            indicationPushVO.setSymptom(indicationPushVO.getSymptom() +
-                    resultBill.getConflictItemName() +
-                    (resultBill.getInputValue() != null ? resultBill.getInputValue() : "") +
-                    (StringUtil.isNotBlank(resultBill.getUnit()) ? resultBill.getUnit() : "") +
-                    ",");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Allergen.getKey())) {
-            indicationPushVO.setPasts(indicationPushVO.getPasts() + "对" + resultBill.getConflictItemName() + "过敏,");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Device.getKey())) {
-            indicationPushVO.setPasts(indicationPushVO.getPasts() + "有" + resultBill.getConflictItemName() + ",");
-        } else if (resultBill.getConflictItemTypeCode().equals(LexiconEnum.Age.getKey())) {
-            indicationPushVO.setAge(resultBill.getInputValue());
         }
-
         return indicationPushVO;
     }
 }

cdssman-service/src/main/java/com/diagbot/facade/ResultRuleFacade.java

@@ -0,0 +1,13 @@
+package com.diagbot.facade;
+
+import com.diagbot.service.impl.ResultRuleServiceImpl;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2021/3/9 11:06
+ */
+@Component
+public class ResultRuleFacade extends ResultRuleServiceImpl {
+}

cdssman-service/src/main/java/com/diagbot/mapper/ResultRuleMapper.java

@@ -0,0 +1,16 @@
+package com.diagbot.mapper;
+
+import com.diagbot.entity.ResultRule;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+
+/**
+ * <p>
+ *  Mapper 接口
+ * </p>
+ *
+ * @author zhaops
+ * @since 2021-03-09
+ */
+public interface ResultRuleMapper extends BaseMapper<ResultRule> {
+
+}

cdssman-service/src/main/java/com/diagbot/service/ResultRuleService.java

@@ -0,0 +1,16 @@
+package com.diagbot.service;
+
+import com.diagbot.entity.ResultRule;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+/**
+ * <p>
+ *  服务类
+ * </p>
+ *
+ * @author zhaops
+ * @since 2021-03-09
+ */
+public interface ResultRuleService extends IService<ResultRule> {
+
+}

cdssman-service/src/main/java/com/diagbot/service/impl/ResultRuleServiceImpl.java

@@ -0,0 +1,20 @@
+package com.diagbot.service.impl;
+
+import com.diagbot.entity.ResultRule;
+import com.diagbot.mapper.ResultRuleMapper;
+import com.diagbot.service.ResultRuleService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ *  服务实现类
+ * </p>
+ *
+ * @author zhaops
+ * @since 2021-03-09
+ */
+@Service
+public class ResultRuleServiceImpl extends ServiceImpl<ResultRuleMapper, ResultRule> implements ResultRuleService {
+
+}

cdssman-service/src/main/resources/mapper/ResultRuleMapper.xml

@@ -0,0 +1,41 @@
+<?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.ResultRuleMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.diagbot.entity.ResultRule">
+        <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="result_id" property="resultId" />
+        <result column="rule_type" property="ruleType" />
+        <result column="rule_lib_type" property="ruleLibType" />
+        <result column="rule_lib_type_name" property="ruleLibTypeName" />
+        <result column="rule_lib_name" property="ruleLibName" />
+        <result column="rule_his_name" property="ruleHisName" />
+        <result column="rule_his_detail_name" property="ruleHisDetailName" />
+        <result column="has_sub_cond" property="hasSubCond" />
+        <result column="group_type" property="groupType" />
+        <result column="rule_base_type" property="ruleBaseType" />
+        <result column="rule_base_lib_type" property="ruleBaseLibType" />
+        <result column="rule_base_lib_type_name" property="ruleBaseLibTypeName" />
+        <result column="rule_base_lib_name" property="ruleBaseLibName" />
+        <result column="rule_base_his_name" property="ruleBaseHisName" />
+        <result column="rule_base_his_detail_name" property="ruleBaseHisDetailName" />
+        <result column="rule_base_max_value" property="ruleBaseMaxValue" />
+        <result column="rule_base_min_value" property="ruleBaseMinValue" />
+        <result column="rule_base_unit" property="ruleBaseUnit" />
+        <result column="rule_base_input_value" property="ruleBaseInputValue" />
+        <result column="reference_value" property="referenceValue" />
+        <result column="output" property="output" />
+        <result column="expected_output" property="expectedOutput" />
+        <result column="success" property="success" />
+        <result column="message" property="message" />
+        <result column="input_params" property="inputParams" />
+        <result column="output_params" property="outputParams" />
+    </resultMap>
+
+</mapper>