Merge branch 'dev/ruleload20210531' into dev/mapping20210603

# Conflicts:
#	src/main/java/com/diagbot/mapper/KlRuleMapper.java
#	src/main/java/com/diagbot/service/KlRuleService.java
#	src/main/java/com/diagbot/service/impl/KlRuleServiceImpl.java
#	src/main/resources/mapper/KlRuleMapper.xml

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

@@ -0,0 +1,110 @@
+package com.diagbot.aggregate;
+
+import com.diagbot.dto.RuleBaseDTO;
+import com.diagbot.dto.RuleBaseInitDTO;
+import com.diagbot.dto.RuleConditionDTO;
+import com.diagbot.dto.RuleConditionInitDTO;
+import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleInitDTO;
+import com.diagbot.enums.RedisEnum;
+import com.diagbot.facade.KlRuleFacade;
+import com.diagbot.util.BeanUtil;
+import com.diagbot.util.EntityUtil;
+import com.diagbot.util.ListUtil;
+import io.github.lvyahui8.spring.annotation.DataConsumer;
+import io.github.lvyahui8.spring.annotation.DataProvider;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.MapUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/5/31 17:14
+ */
+@Component
+@Slf4j
+public class RuleAggregate {
+    @Autowired
+    private KlRuleFacade klRuleFacade;
+
+    @DataProvider("getAllRules")
+    public Map<String, RuleDTO> getAllRules(
+            @DataConsumer("getRuleInit") Map<String, List<RuleInitDTO>> ruleInits,
+            @DataConsumer("getRuleConditionInit") Map<Integer, Map<String, List<RuleConditionInitDTO>>> ruleConditionInits,
+            @DataConsumer("getRuleBaseInit") Map<Integer, RuleBaseInitDTO> ruleBaseInits) {
+        Map<String, RuleDTO> res = new HashMap();
+        //结果判空第一层规则类型
+        if (MapUtils.isNotEmpty(ruleInits)) {
+            for (String ruleKey : ruleInits.keySet()) {
+                RuleInitDTO ruleInitZeroDTO = ruleInits.get(ruleKey).get(0);
+                RuleDTO ruleDTO = new RuleDTO();
+                ruleDTO.setLibName(ruleInitZeroDTO.getLibName());
+                ruleDTO.setLibType(ruleInitZeroDTO.getLibType());
+                ruleDTO.setRuleType(ruleInitZeroDTO.getRuleType());
+                for (RuleInitDTO ruleInitDTO : ruleInits.get(ruleKey)) {
+                    if (ruleInitDTO.getHasSubCond().equals(1)) {
+                        Map<String, List<RuleConditionInitDTO>> map = ruleConditionInits.get(ruleInitDTO.getRuleId());
+                        //结果判空第二层条件组别
+                        if (MapUtils.isNotEmpty(map)) {
+                            for (String key : map.keySet()) {
+                                RuleConditionDTO ruleConditionDTO = new RuleConditionDTO();
+                                ruleConditionDTO.setHasSubCond(ruleInitDTO.getHasSubCond());
+                                ruleConditionDTO.setMsg(ruleInitDTO.getMsg());
+                                ruleConditionDTO.setRuleGroup(key);
+                                //结果判空第三层条件明细
+                                if (ListUtil.isNotEmpty(map.get(key))) {
+                                    for (RuleConditionInitDTO ruleConditionInitDTO : map.get(key)) {
+                                        RuleBaseDTO ruleBaseDTO = new RuleBaseDTO();
+                                        BeanUtil.copyProperties(ruleBaseInits.get(ruleConditionInitDTO.getRuleBaseId()), ruleBaseDTO);
+                                        ruleConditionDTO.getRuleBaseDTOList().add(ruleBaseDTO);
+                                    }
+                                }
+                                ruleDTO.getRuleConditionDTOList().add(ruleConditionDTO);
+                            }
+                        }
+                    } else {
+                        RuleConditionDTO ruleConditionDTO = new RuleConditionDTO();
+                        ruleConditionDTO.setHasSubCond(ruleInitDTO.getHasSubCond());
+                        ruleConditionDTO.setMsg(ruleInitDTO.getMsg());
+                        //无条件
+                        ruleConditionDTO.setRuleGroup(ruleInitDTO.getRuleId() + "-1");
+                        ruleConditionDTO.getRuleBaseDTOList().add(new RuleBaseDTO());
+                        ruleDTO.getRuleConditionDTOList().add(ruleConditionDTO);
+                    }
+                }
+                res.put(RedisEnum.allRule.getName() + ruleDTO.getLibType() + "_" + ruleDTO.getLibName() + "_" + ruleDTO.getRuleType(), ruleDTO);
+            }
+        }
+        return res;
+    }
+
+    @DataProvider("getRuleInit")
+    public Map<String, List<RuleInitDTO>> getRuleInit() {
+        List<RuleInitDTO> list = klRuleFacade.getRuleInitDTO();
+        return EntityUtil.makeEntityListMap(list, "conceptGroup");
+    }
+
+    @DataProvider("getRuleConditionInit")
+    public Map<Integer, Map<String, List<RuleConditionInitDTO>>> getRuleConditionInit() {
+        List<RuleConditionInitDTO> list = klRuleFacade.getRuleConditionInitDTO();
+        Map<Integer, List<RuleConditionInitDTO>> map = EntityUtil.makeEntityListMap(list, "ruleId");
+        Map<Integer, Map<String, List<RuleConditionInitDTO>>> res = new HashMap<>();
+        for (Integer key : map.keySet()) {
+            res.put(key, EntityUtil.makeEntityListMap(map.get(key), "ruleGroup"));
+        }
+        return res;
+    }
+
+
+    @DataProvider("getRuleBaseInit")
+    public Map<Integer, RuleBaseInitDTO> getRuleBaseInit() {
+        List<RuleBaseInitDTO> list = klRuleFacade.getRuleBaseInitDTO();
+        return EntityUtil.makeEntityMap(list, "ruleBaseId");
+    }
+}

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

@@ -11,16 +11,16 @@ import lombok.Setter;
 @Getter
 @Setter
 public class RuleBaseDTO {
-    private String baseLibName;
-    private Integer baseLibType;
-    private Integer baseType;
-    private String baseMinOperator;
-    private String baseMinValue;
-    private String baseMinUnit;
-    private String baseMaxOperator;
-    private String baseMaxValue;
-    private String baseMaxUnit;
-    private String baseEqOperator;
-    private String baseEqValue;
-    private String baseEqUnit;
+    private String baseLibName = "";
+    private Integer baseLibType = 0;
+    private Integer baseType = 0;
+    private String baseMinOperator = "";
+    private String baseMinValue = "";
+    private String baseMinUnit = "";
+    private String baseMaxOperator = "";
+    private String baseMaxValue = "";
+    private String baseMaxUnit = "";
+    private String baseEqOperator = "";
+    private String baseEqValue = "";
+    private String baseEqUnit = "";
 }

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

@@ -0,0 +1,15 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/2/3 16:25
+ */
+@Getter
+@Setter
+public class RuleBaseInitDTO extends RuleBaseDTO {
+    private Integer ruleBaseId;
+}

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

@@ -0,0 +1,20 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/2/3 16:32
+ */
+@Getter
+@Setter
+public class RuleConditionInitDTO {
+    private Integer ruleId;
+    private String ruleGroup;
+    private Integer ruleBaseId;
+}

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

@@ -0,0 +1,25 @@
+package com.diagbot.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2021/2/3 16:34
+ */
+@Getter
+@Setter
+public class RuleInitDTO {
+    private String conceptGroup;
+    private Integer conceptId;
+    private Integer ruleId;
+    private String libName;
+    private Integer libType;
+    private Integer ruleType;
+    private String msg;
+    private Integer hasSubCond;
+}

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

@@ -16,6 +16,8 @@ import com.diagbot.entity.TranHospitalFilter;
 import com.diagbot.enums.IsDeleteEnum;
 import com.diagbot.enums.PushRelationTypeEnum;
 import com.diagbot.enums.RedisEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.model.entity.PD;
 import com.diagbot.service.KlDiseaseCorrespondingService;
 import com.diagbot.service.SymptomFeatureService;
@@ -32,6 +34,8 @@ import com.diagbot.vo.neoPushEntity.PresentPushVo;
 import com.diagbot.vo.neoPushEntity.Symptom;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
+import io.github.lvyahui8.spring.facade.DataFacade;
+import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections.MapUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -54,6 +58,7 @@ import static com.diagbot.util.StringUtil.permutationNoRepeat;
  * @time: 2018/8/6 9:11
  */
 @Component
+@Slf4j
 public class NeoFacade {
     @Autowired
     NeoFacade self;
@@ -482,14 +487,21 @@ public class NeoFacade {
     }
 
     public void allRuleCache() {
-        List<RuleDTO> ruleDTOList = klRuleFacade.getAllRule();
-        if (ListUtil.isNotEmpty(ruleDTOList)) {
-            Map map = ruleDTOList.stream().collect(Collectors.toMap(
-                    k -> RedisEnum.allRule.getName() + k.getLibType() + "_" + k.getLibName() + "_" + k.getRuleType(),
-                    v -> v,
-                    (v1, v2) -> (v2)
-            ));
+//        List<RuleDTO> ruleDTOList = klRuleFacade.getAllRule();
+//        if (ListUtil.isNotEmpty(ruleDTOList)) {
+//            Map map = ruleDTOList.stream().collect(Collectors.toMap(
+//                    k -> RedisEnum.allRule.getName() + k.getLibType() + "_" + k.getLibName() + "_" + k.getRuleType(),
+//                    v -> v,
+//                    (v1, v2) -> (v2)
+//            ));
+//            redisTemplate.opsForValue().multiSet(map);
+//        }
+        try {
+            Map<String, Object> invokeParams = new HashMap<>();
+            Map<String, RuleDTO> map = DataFacade.get("getAllRules", invokeParams, Map.class);
             redisTemplate.opsForValue().multiSet(map);
+        } catch (Exception e) {
+            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "获取所有规则失败" + e.getMessage());
         }
     }
 

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

@@ -4,7 +4,10 @@ import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.diagbot.dto.IndicationExportDTO;
 import com.diagbot.dto.KlRuleByIdDTO;
 import com.diagbot.dto.KlRuleInfoDTO;
+import com.diagbot.dto.RuleBaseInitDTO;
+import com.diagbot.dto.RuleConditionInitDTO;
 import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleInitDTO;
 import com.diagbot.entity.KlRule;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.diagbot.vo.KlRuleByIdVO;
@@ -29,4 +32,10 @@ public interface KlRuleMapper extends BaseMapper<KlRule> {
     List<KlRuleByIdDTO> getByIdRuleInfo(KlRuleByIdVO klRuleByIdVO);
 
     List<IndicationExportDTO> exportIndication();
+
+    List<RuleInitDTO> getRuleInitDTO();
+
+    List<RuleConditionInitDTO> getRuleConditionInitDTO();
+
+    List<RuleBaseInitDTO> getRuleBaseInitDTO();
 }

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

@@ -5,7 +5,10 @@ import com.baomidou.mybatisplus.extension.service.IService;
 import com.diagbot.dto.IndicationExportDTO;
 import com.diagbot.dto.KlRuleByIdDTO;
 import com.diagbot.dto.KlRuleInfoDTO;
+import com.diagbot.dto.RuleBaseInitDTO;
+import com.diagbot.dto.RuleConditionInitDTO;
 import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleInitDTO;
 import com.diagbot.entity.KlRule;
 import com.diagbot.vo.KlRuleByIdVO;
 import com.diagbot.vo.KlRuleInfoVO;
@@ -25,4 +28,10 @@ public interface KlRuleService extends IService<KlRule> {
     IPage<KlRuleInfoDTO> getKlRuleInfoPages(KlRuleInfoVO klRuleInfoVO);
     List<KlRuleByIdDTO> getByIdRuleInfo(KlRuleByIdVO klRuleByIdVO);
     List<IndicationExportDTO> exportIndication();
+
+    List<RuleInitDTO> getRuleInitDTO();
+
+    List<RuleConditionInitDTO> getRuleConditionInitDTO();
+
+    List<RuleBaseInitDTO> getRuleBaseInitDTO();
 }

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

@@ -5,7 +5,10 @@ import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.diagbot.dto.IndicationExportDTO;
 import com.diagbot.dto.KlRuleByIdDTO;
 import com.diagbot.dto.KlRuleInfoDTO;
+import com.diagbot.dto.RuleBaseInitDTO;
+import com.diagbot.dto.RuleConditionInitDTO;
 import com.diagbot.dto.RuleDTO;
+import com.diagbot.dto.RuleInitDTO;
 import com.diagbot.entity.KlRule;
 import com.diagbot.mapper.KlRuleMapper;
 import com.diagbot.service.KlRuleService;
@@ -43,4 +46,19 @@ public class KlRuleServiceImpl extends ServiceImpl<KlRuleMapper, KlRule> impleme
     public List<IndicationExportDTO> exportIndication() {
         return baseMapper.exportIndication();
     }
+
+    @Override
+    public List<RuleInitDTO> getRuleInitDTO(){
+        return baseMapper.getRuleInitDTO();
+    }
+
+    @Override
+    public List<RuleConditionInitDTO> getRuleConditionInitDTO(){
+        return baseMapper.getRuleConditionInitDTO();
+    }
+
+    @Override
+    public List<RuleBaseInitDTO> getRuleBaseInitDTO(){
+        return baseMapper.getRuleBaseInitDTO();
+    }
 }

src/main/resources/mapper/KlRuleMapper.xml

@@ -292,4 +292,67 @@
         ORDER BY
             rule_id
     </select>
+
+    <select id="getRuleInitDTO" resultType="com.diagbot.dto.RuleInitDTO">
+        SELECT
+            CONCAT_WS("_",t1.concept_id,t1.rule_type) AS conceptGroup,
+            t1.id AS ruleId,
+            t4.lib_name AS libName,
+            t4.lib_type AS libType,
+            t1.rule_type AS ruleType,
+            t1.msg AS msg,
+            t1.has_sub_cond AS hasSubCond
+        FROM
+            kl_rule t1,
+            kl_concept t4
+        WHERE
+            t1.is_deleted = "N"
+        AND t4.is_deleted = "N"
+        AND t1.concept_id = t4.id
+        AND t1. STATUS = 1
+        AND t4. STATUS = 1
+        ORDER BY
+            t1.concept_id,
+            t1.rule_type,
+            t1.has_sub_cond
+    </select>
+
+    <select id="getRuleConditionInitDTO" resultType="com.diagbot.dto.RuleConditionInitDTO">
+        SELECT
+            t2.rule_id AS ruleId,
+            CONCAT_WS("-", t2.rule_id, t2.group_type) AS ruleGroup,
+            t2.rule_base_id as ruleBaseId
+        FROM
+            kl_rule_condition t2
+        ORDER BY
+            t2.rule_id,
+            t2.group_type,
+            t2.rule_base_id
+    </select>
+
+    <select id="getRuleBaseInitDTO" resultType="com.diagbot.dto.RuleBaseInitDTO">
+        SELECT
+            t3.id as ruleBaseId,
+            t5.lib_name AS baseLibName,
+            t5.lib_type AS baseLibType,
+            t3.type AS baseType,
+            t3.min_operator AS baseMinOperator,
+            t3.min_value AS baseMinValue,
+            t3.min_unit AS baseMinUnit,
+            t3.max_operator AS baseMaxOperator,
+            t3.max_value AS baseMaxValue,
+            t3.max_unit AS baseMaxUnit,
+            t3.eq_operator AS baseEqOperator,
+            t3.eq_value AS baseEqValue,
+            t3.eq_unit AS baseEqUnit
+        FROM
+            kl_rule_base t3,
+            kl_concept t5
+        WHERE
+            t3.is_deleted = "N"
+        AND t5.is_deleted = "N"
+        AND t3. STATUS = 1
+        AND t5. STATUS = 1
+        AND t3.concept_id = t5.id
+    </select>
 </mapper>