推理

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

@@ -0,0 +1,324 @@
+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.util.BeanUtil;
+import com.diagbot.util.ListUtil;
+import com.diagbot.util.StringUtil;
+import com.diagbot.vo.SearchData;
+import com.google.common.collect.Lists;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/4 14:09
+ */
+@Component
+public class AssembleFacade {
+    @Autowired
+    private LisConfigFacade lisConfigFacade;
+    @Autowired
+    private PacsConfigFacade pacsConfigFacade;
+    @Autowired
+    private DiseaseConfigFacade diseaseConfigFacade;
+    @Autowired
+    private DrugConfigFacade drugConfigFacade;
+    @Autowired
+    private OperationConfigFacade operationConfigFacade;
+
+    public SearchData assembleData(SearchData searchData) {
+
+        //化验公表转换
+        List<String> lisHisNameList = Lists.newArrayList();
+        //lis
+        if (ListUtil.isNotEmpty(searchData.getLis())) {
+            lisHisNameList.addAll(searchData.getLis()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //lisOrder
+        if (ListUtil.isNotEmpty(searchData.getLisOrder())) {
+            lisHisNameList.addAll(searchData.getLisOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        lisHisNameList = lisHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (ListUtil.isNotEmpty(lisHisNameList)) {
+            Map<String, Map<String, Map<String, Long>>> lisConfigMap
+                    = lisConfigFacade.getConfigMap(searchData.getHospitalId(), lisHisNameList, null);
+            if (ListUtil.isNotEmpty(searchData.getLis())) {
+                List<Lis> convertLis = lisConvert(searchData.getLis(), lisConfigMap);
+                searchData.setLis(convertLis);
+            }
+            if (ListUtil.isNotEmpty(searchData.getLisOrder())) {
+                List<Lis> convertLis = lisConvert(searchData.getLisOrder(), lisConfigMap);
+                searchData.setLisOrder(convertLis);
+            }
+        }
+
+        //化验公表转换
+        List<String> pacsHisNameList = Lists.newArrayList();
+        //pacs
+        if (ListUtil.isNotEmpty(searchData.getPacs())) {
+            pacsHisNameList.addAll(searchData.getPacs()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //pacsOrder
+        if (ListUtil.isNotEmpty(searchData.getPacsOrder())) {
+            pacsHisNameList.addAll(searchData.getPacsOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        pacsHisNameList = pacsHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (ListUtil.isNotEmpty(pacsHisNameList)) {
+            Map<String, Map<String, Long>> pacsConfigMap
+                    = pacsConfigFacade.getConfigMap(searchData.getHospitalId(), pacsHisNameList, null);
+            if (ListUtil.isNotEmpty(searchData.getPacs())) {
+                List<Pacs> convertPacs = pacsConvert(searchData.getPacs(), pacsConfigMap);
+                searchData.setPacs(convertPacs);
+            }
+            if (ListUtil.isNotEmpty(searchData.getPacsOrder())) {
+                List<Pacs> convertPacs = pacsConvert(searchData.getPacsOrder(), pacsConfigMap);
+                searchData.setPacsOrder(convertPacs);
+            }
+        }
+
+        //诊断公表转换
+        List<String> diagHisNameList = Lists.newArrayList();
+        //diag
+        if (ListUtil.isNotEmpty(searchData.getDiag())) {
+            diagHisNameList.addAll(searchData.getDiag()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //diagOrder
+        if (ListUtil.isNotEmpty(searchData.getDiagOrder())) {
+            diagHisNameList.addAll(searchData.getDiagOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        diagHisNameList = diagHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (ListUtil.isNotEmpty(diagHisNameList)) {
+            Map<String, Map<String, Long>> configMap
+                    = diseaseConfigFacade.getConfigMap(searchData.getHospitalId(), diagHisNameList, null);
+            if (ListUtil.isNotEmpty(searchData.getDiag())) {
+                List<Item> convertItem = itemConvert(searchData.getDiag(), configMap);
+                searchData.setDiag(convertItem);
+            }
+            if (ListUtil.isNotEmpty(searchData.getDiagOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getDiagOrder(), configMap);
+                searchData.setDiagOrder(convertItem);
+            }
+        }
+
+        //药品公表转换
+        List<String> drugHisNameList = Lists.newArrayList();
+        //drug
+        if (ListUtil.isNotEmpty(searchData.getDrug())) {
+            drugHisNameList.addAll(searchData.getDrug()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //drugOrder
+        if (ListUtil.isNotEmpty(searchData.getDrugOrder())) {
+            drugHisNameList.addAll(searchData.getDrugOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        drugHisNameList = drugHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (ListUtil.isNotEmpty(drugHisNameList)) {
+            Map<String, Map<String, Long>> configMap
+                    = drugConfigFacade.getConfigMap(searchData.getHospitalId(), drugHisNameList, null);
+            if (ListUtil.isNotEmpty(searchData.getDrug())) {
+                List<Item> convertItem = itemConvert(searchData.getDrug(), configMap);
+                searchData.setDrug(convertItem);
+            }
+            if (ListUtil.isNotEmpty(searchData.getDrugOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getDrugOrder(), configMap);
+                searchData.setDrugOrder(convertItem);
+            }
+        }
+
+        //手术公表转换
+        List<String> operationHisNameList = Lists.newArrayList();
+        //operationOrder
+        if (ListUtil.isNotEmpty(searchData.getOperationOrder())) {
+            operationHisNameList.addAll(searchData.getOperationOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        operationHisNameList = operationHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (ListUtil.isNotEmpty(operationHisNameList)) {
+            Map<String, Map<String, Long>> configMap
+                    = operationConfigFacade.getConfigMap(searchData.getHospitalId(), operationHisNameList, null);
+            if (ListUtil.isNotEmpty(searchData.getOperationOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getOperationOrder(), configMap);
+                searchData.setOperationOrder(convertItem);
+            }
+        }
+
+
+        return searchData;
+    }
+
+    /**
+     * 化验公表转换
+     *
+     * @param lis
+     * @param configMap
+     * @return
+     */
+    public List<Lis> lisConvert(List<Lis> lis, Map<String, Map<String, Map<String, Long>>> configMap) {
+        if (ListUtil.isEmpty(lis)) {
+            return lis;
+        }
+        if (configMap == null || configMap.size() == 0) {
+            return lis;
+        }
+        List<Lis> convertLis = Lists.newLinkedList();
+
+        lis.forEach(lisRecord -> {
+            if (StringUtil.isBlank(lisRecord.getName())) {
+                convertLis.add(lisRecord);
+            } else {
+                Map<String, Long> uniqueNameMap = new HashMap<>();
+                if (StringUtil.isBlank(lisRecord.getDetailName())) {
+                    lisRecord.setDetailName("");
+                }
+                if (configMap.get(lisRecord.getName()) != null
+                        && configMap.get(lisRecord.getName()).containsKey(lisRecord.getDetailName())) {
+                    uniqueNameMap = configMap.get(lisRecord.getName()).get(lisRecord.getDetailName());
+                }
+                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                    for (String uniqueName : uniqueNameMap.keySet()) {
+                        Lis convertLisRecord = new Lis();
+                        BeanUtil.copyProperties(lisRecord, convertLisRecord);
+                        convertLisRecord.setUniqueName(uniqueName);
+                        convertLis.add(convertLisRecord);
+                    }
+                }
+            }
+        });
+        return convertLis;
+    }
+
+    /**
+     * 辅检公表转换
+     *
+     * @param pacs
+     * @param configMap
+     * @return
+     */
+    public List<Pacs> pacsConvert(List<Pacs> pacs, Map<String, Map<String, Long>> configMap) {
+        if (ListUtil.isEmpty(pacs)) {
+            return pacs;
+        }
+        if (configMap == null || configMap.size() == 0) {
+            return pacs;
+        }
+        List<Pacs> convertPacs = Lists.newLinkedList();
+
+        pacs.forEach(pacsRecord -> {
+            if (StringUtil.isBlank(pacsRecord.getName())) {
+                convertPacs.add(pacsRecord);
+            } else {
+                Map<String, Long> uniqueNameMap = new HashMap<>();
+                if (configMap.get(pacsRecord.getName()) != null) {
+                    uniqueNameMap = configMap.get(pacsRecord.getName());
+                }
+                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                    for (String uniqueName : uniqueNameMap.keySet()) {
+                        Pacs convertPacsRecord = new Pacs();
+                        BeanUtil.copyProperties(pacsRecord, convertPacsRecord);
+                        convertPacsRecord.setUniqueName(uniqueName);
+                        convertPacs.add(convertPacsRecord);
+                    }
+                }
+            }
+        });
+        return convertPacs;
+    }
+
+    /**
+     * 药品、手术、诊断转换
+     *
+     * @param items
+     * @param configMap
+     * @return
+     */
+    public List<Item> itemConvert(List<Item> items, Map<String, Map<String, Long>> configMap) {
+        if (ListUtil.isEmpty(items)) {
+            return items;
+        }
+        if (configMap == null || configMap.size() == 0) {
+            return items;
+        }
+        List<Item> convertItem = Lists.newLinkedList();
+        items.forEach(item -> {
+            if (StringUtil.isBlank(item.getName())) {
+                convertItem.add(item);
+            } else {
+                Map<String, Long> uniqueNameMap = new HashMap<>();
+                if (configMap.get(item.getName()) != null) {
+                    uniqueNameMap = configMap.get(item.getName());
+                }
+                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                    for (String uniqueName : uniqueNameMap.keySet()) {
+                        Item convertItemRecord = new Item();
+                        BeanUtil.copyProperties(item, convertItemRecord);
+                        convertItemRecord.setUniqueName(uniqueName);
+                        convertItem.add(convertItemRecord);
+                    }
+                }
+            }
+        });
+        return convertItem;
+    }
+}

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

@@ -0,0 +1,43 @@
+package com.diagbot.facade;
+
+import com.diagbot.util.BeanUtil;
+import com.diagbot.vo.IndicationPushVO;
+import com.diagbot.vo.PushVO;
+import com.diagbot.vo.SearchData;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+/**
+ * @Description:
+ * @Author:zhaops
+ * @time: 2020/8/4 14:08
+ */
+@Component
+public class PushFacade {
+    @Autowired
+    private AssembleFacade assembleFacade;
+
+    /**
+     * 基础推理
+     *
+     * @param pushVO
+     */
+    public void push(PushVO pushVO) {
+        SearchData searchData = new SearchData();
+        BeanUtil.copyProperties(pushVO, searchData);
+        searchData = assembleFacade.assembleData(searchData);
+        BeanUtil.copyProperties(searchData, pushVO);
+    }
+
+    /**
+     * 提示信息相关推理-危急值、开单合理项、药品禁忌等
+     *
+     * @param indicationPushVO
+     */
+    public void indicationPush(IndicationPushVO indicationPushVO) {
+        SearchData searchData = new SearchData();
+        BeanUtil.copyProperties(indicationPushVO, searchData);
+        searchData = assembleFacade.assembleData(searchData);
+        BeanUtil.copyProperties(searchData, indicationPushVO);
+    }
+}