入出参术语映射改成多线程

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

@@ -0,0 +1,420 @@
+package com.diagbot.aggregate;
+
+import com.diagbot.biz.push.entity.Item;
+import com.diagbot.biz.push.entity.Lis;
+import com.diagbot.biz.push.entity.Pacs;
+import com.diagbot.facade.DeptConfigFacade;
+import com.diagbot.facade.DiseaseConfigFacade;
+import com.diagbot.facade.DrugConfigFacade;
+import com.diagbot.facade.LisConfigFacade;
+import com.diagbot.facade.OperationConfigFacade;
+import com.diagbot.facade.PacsConfigFacade;
+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 io.github.lvyahui8.spring.annotation.DataConsumer;
+import io.github.lvyahui8.spring.annotation.DataProvider;
+import io.github.lvyahui8.spring.annotation.InvokeParameter;
+import org.apache.commons.collections4.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;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2020/8/19 13:18
+ */
+@Component
+public class AssembleAggregate {
+    @Autowired
+    private LisConfigFacade lisConfigFacade;
+    @Autowired
+    private PacsConfigFacade pacsConfigFacade;
+    @Autowired
+    private DiseaseConfigFacade diseaseConfigFacade;
+    @Autowired
+    private DrugConfigFacade drugConfigFacade;
+    @Autowired
+    private OperationConfigFacade operationConfigFacade;
+    @Autowired
+    private DeptConfigFacade deptConfigFacade;
+
+    @DataProvider("assembleDataAll")
+    public SearchData assembleDataAll(
+            @InvokeParameter("searchData") SearchData searchData,
+            @DataConsumer("lisConfigMap") Map<String, Map<String, Map<String, Long>>> lisConfigMap,
+            @DataConsumer("pacsConfigMap") Map<String, Map<String, Long>> pacsConfigMap,
+            @DataConsumer("diagConfigMap") Map<String, Map<String, Long>> diagConfigMap,
+            @DataConsumer("drugConfigMap") Map<String, Map<String, Long>> drugConfigMap,
+            @DataConsumer("operationConfigMap") Map<String, Map<String, Long>> operationConfigMap,
+            @DataConsumer("deptConfigMap") Map<String, Map<String, Long>> deptConfigMap) {
+        //检验
+        if (MapUtils.isNotEmpty(lisConfigMap)) {
+            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);
+            }
+        }
+        //检查
+        if (MapUtils.isNotEmpty(pacsConfigMap)) {
+            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);
+            }
+        }
+        //诊断
+        if (MapUtils.isNotEmpty(diagConfigMap)) {
+            if (ListUtil.isNotEmpty(searchData.getDiag())) {
+                List<Item> convertItem = itemConvert(searchData.getDiag(), diagConfigMap);
+                searchData.setDiag(convertItem);
+            }
+            if (ListUtil.isNotEmpty(searchData.getDiagOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getDiagOrder(), diagConfigMap);
+                searchData.setDiagOrder(convertItem);
+            }
+        }
+        //药品
+        if (MapUtils.isNotEmpty(drugConfigMap)) {
+            if (ListUtil.isNotEmpty(searchData.getDrug())) {
+                List<Item> convertItem = itemConvert(searchData.getDrug(), drugConfigMap);
+                searchData.setDrug(convertItem);
+            }
+            if (ListUtil.isNotEmpty(searchData.getDrugOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getDrugOrder(), drugConfigMap);
+                searchData.setDrugOrder(convertItem);
+            }
+        }
+        //手术
+        if (MapUtils.isNotEmpty(operationConfigMap)) {
+            if (ListUtil.isNotEmpty(searchData.getOperationOrder())) {
+                List<Item> convertItem = itemConvert(searchData.getOperationOrder(), operationConfigMap);
+                searchData.setOperationOrder(convertItem);
+            }
+        }
+        //科室
+        if (MapUtils.isNotEmpty(deptConfigMap)) {
+            if (ListUtil.isNotEmpty(searchData.getDept())) {
+                List<Item> convertItem = itemConvert(searchData.getDept(), deptConfigMap);
+                searchData.setDept(convertItem);
+            }
+        }
+
+
+        return searchData;
+    }
+
+    @DataProvider("lisConfigMap")
+    public Map<String, Map<String, Map<String, Long>>> lisConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //化验公表转换
+        List<String> lisHisNameList = Lists.newArrayList();
+        //lis
+        if (ListUtil.isNotEmpty(searchData.getLis())) {
+            lisHisNameList.addAll(searchData.getLis()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //lisOrder
+        if (ListUtil.isNotEmpty(searchData.getLisOrder())) {
+            lisHisNameList.addAll(searchData.getLisOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        lisHisNameList = lisHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Map<String, Long>>> lisConfigMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(lisHisNameList)) {
+            lisConfigMap
+                    = lisConfigFacade.getConfigMap(searchData.getHospitalId(), lisHisNameList, null);
+        }
+        return lisConfigMap;
+    }
+
+    @DataProvider("pacsConfigMap")
+    public Map<String, Map<String, Long>> pacsConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //辅检公表转换
+        List<String> pacsHisNameList = Lists.newArrayList();
+        //pacs
+        if (ListUtil.isNotEmpty(searchData.getPacs())) {
+            pacsHisNameList.addAll(searchData.getPacs()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //pacsOrder
+        if (ListUtil.isNotEmpty(searchData.getPacsOrder())) {
+            pacsHisNameList.addAll(searchData.getPacsOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        pacsHisNameList = pacsHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Long>> pacsConfigMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(pacsHisNameList)) {
+            pacsConfigMap
+                    = pacsConfigFacade.getConfigMap(searchData.getHospitalId(), pacsHisNameList, null);
+        }
+        return pacsConfigMap;
+    }
+
+    @DataProvider("diagConfigMap")
+    public Map<String, Map<String, Long>> diagConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //诊断公表转换
+        List<String> diagHisNameList = Lists.newArrayList();
+        //diag
+        if (ListUtil.isNotEmpty(searchData.getDiag())) {
+            diagHisNameList.addAll(searchData.getDiag()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //diagOrder
+        if (ListUtil.isNotEmpty(searchData.getDiagOrder())) {
+            diagHisNameList.addAll(searchData.getDiagOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        diagHisNameList = diagHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Long>> configMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(diagHisNameList)) {
+            configMap
+                    = diseaseConfigFacade.getConfigMap(searchData.getHospitalId(), diagHisNameList, null);
+        }
+        return configMap;
+    }
+
+    @DataProvider("drugConfigMap")
+    public Map<String, Map<String, Long>> drugConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //药品公表转换
+        List<String> drugHisNameList = Lists.newArrayList();
+        //drug
+        if (ListUtil.isNotEmpty(searchData.getDrug())) {
+            drugHisNameList.addAll(searchData.getDrug()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        //drugOrder
+        if (ListUtil.isNotEmpty(searchData.getDrugOrder())) {
+            drugHisNameList.addAll(searchData.getDrugOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        drugHisNameList = drugHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Long>> configMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(drugHisNameList)) {
+            configMap
+                    = drugConfigFacade.getConfigMap(searchData.getHospitalId(), drugHisNameList, null);
+        }
+        return configMap;
+    }
+
+    @DataProvider("operationConfigMap")
+    public Map<String, Map<String, Long>> operationConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //手术公表转换
+        List<String> operationHisNameList = Lists.newArrayList();
+        //operationOrder
+        if (ListUtil.isNotEmpty(searchData.getOperationOrder())) {
+            operationHisNameList.addAll(searchData.getOperationOrder()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        operationHisNameList = operationHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Long>> configMap = new HashMap<>();
+        if (ListUtil.isNotEmpty(operationHisNameList)) {
+            configMap
+                    = operationConfigFacade.getConfigMap(searchData.getHospitalId(), operationHisNameList, null);
+        }
+        return configMap;
+    }
+
+    @DataProvider("deptConfigMap")
+    public Map<String, Map<String, Long>> deptConfigMap(@InvokeParameter("searchData") SearchData searchData) {
+        //科室公表转换
+        List<String> deptHisNameList = Lists.newArrayList();
+        //dept
+        if (ListUtil.isNotEmpty(searchData.getDept())) {
+            deptHisNameList.addAll(searchData.getDept()
+                    .stream()
+                    .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList()));
+        }
+        deptHisNameList = deptHisNameList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        Map<String, Map<String, Long>> configMap = new HashMap<>();
+
+        if (ListUtil.isNotEmpty(deptHisNameList)) {
+            configMap
+                    = deptConfigFacade.getConfigMap(searchData.getHospitalId(), deptHisNameList, null);
+        }
+        return configMap;
+    }
+
+    /**
+     * 化验公表转换
+     *
+     * @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())
+                    || StringUtil.isNotBlank(lisRecord.getUniqueName())) {
+                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())
+                    || StringUtil.isNotBlank(pacsRecord.getUniqueName())) {
+                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())
+                    || StringUtil.isNotBlank(item.getUniqueName())) {
+                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/aggregate/AssemblePushAggregate.java

@@ -0,0 +1,195 @@
+package com.diagbot.aggregate;
+
+import com.diagbot.dto.PushBaseDTO;
+import com.diagbot.dto.PushDTO;
+import com.diagbot.facade.DiseaseConfigFacade;
+import com.diagbot.facade.DrugConfigFacade;
+import com.diagbot.facade.LisConfigFacade;
+import com.diagbot.facade.OperationConfigFacade;
+import com.diagbot.facade.PacsConfigFacade;
+import com.diagbot.util.ListUtil;
+import com.google.common.collect.Lists;
+import io.github.lvyahui8.spring.annotation.DataConsumer;
+import io.github.lvyahui8.spring.annotation.DataProvider;
+import io.github.lvyahui8.spring.annotation.InvokeParameter;
+import org.apache.commons.collections4.MapUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+/**
+ * @Description:
+ * @author: gaodm
+ * @time: 2020/8/19 13:50
+ */
+@Component
+public class AssemblePushAggregate {
+
+    @Autowired
+    private LisConfigFacade lisConfigFacade;
+    @Autowired
+    private PacsConfigFacade pacsConfigFacade;
+    @Autowired
+    private DiseaseConfigFacade diseaseConfigFacade;
+    @Autowired
+    private DrugConfigFacade drugConfigFacade;
+    @Autowired
+    private OperationConfigFacade operationConfigFacade;
+
+    @DataProvider("assemblePushAll")
+    public PushDTO assemblePushAll(
+            @InvokeParameter("pushDTO") PushDTO data,
+            @InvokeParameter("hospitalId") Long hospitalId,
+            @DataConsumer("retLis") List<PushBaseDTO> retLis,
+            @DataConsumer("retPacs") List<PushBaseDTO> retPacs,
+            @DataConsumer("retDiagMap") Map<String, List<PushBaseDTO>> retDiagMap,
+            @DataConsumer("retOperation") List<PushBaseDTO> retOperation,
+            @DataConsumer("retDrug") List<PushBaseDTO> retDrug) {
+        if (ListUtil.isNotEmpty(retLis)) {
+            data.setLis(retLis);
+        }
+        if (ListUtil.isNotEmpty(retPacs)) {
+            data.setPacs(retPacs);
+        }
+        if (MapUtils.isNotEmpty(retDiagMap)) {
+            data.setDis(retDiagMap);
+        }
+        if (ListUtil.isNotEmpty(retOperation)) {
+            data.setOperations(retOperation);
+        }
+        if (ListUtil.isNotEmpty(retDrug)) {
+            data.setMedicines(retDrug);
+        }
+
+        return data;
+    }
+
+    @DataProvider("retLis")
+    public List<PushBaseDTO> retLis(@InvokeParameter("pushDTO") PushDTO data,
+                                    @InvokeParameter("hospitalId") Long hospitalId) {
+        //检验
+        List<PushBaseDTO> retLis = new ArrayList<>();
+        if (ListUtil.isNotEmpty(data.getLis())) {
+            retLis = data.getLis();
+            List<String> uniqueNameList = retLis.stream()
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList());
+            Map<String, Map<String, Long>> uniqueNameMap
+                    = lisConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
+            if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                retLis.forEach(item -> {
+                    if (uniqueNameMap.get(item.getName()) != null) {
+                        item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
+                    }
+                });
+
+            }
+        }
+        return retLis;
+    }
+
+    @DataProvider("retPacs")
+    public List<PushBaseDTO> retPacs(@InvokeParameter("pushDTO") PushDTO data,
+                                     @InvokeParameter("hospitalId") Long hospitalId) {
+        //检查
+        List<PushBaseDTO> retPacs = new ArrayList<>();
+        if (ListUtil.isNotEmpty(data.getPacs())) {
+            retPacs = data.getPacs();
+            List<String> uniqueNameList = retPacs.stream()
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList());
+            Map<String, Map<String, Long>> uniqueNameMap
+                    = pacsConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
+            if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                retPacs.forEach(item -> {
+                    if (uniqueNameMap.get(item.getName()) != null) {
+                        item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
+                    }
+                });
+            }
+        }
+        return retPacs;
+    }
+
+    @DataProvider("retDiagMap")
+    public Map<String, List<PushBaseDTO>> retDiagMap(@InvokeParameter("pushDTO") PushDTO data,
+                                                     @InvokeParameter("hospitalId") Long hospitalId) {
+        Map<String, List<PushBaseDTO>> retMap = new HashMap<>();
+        if (data.getDis() != null && data.getDis().size() > 0) {
+            retMap = data.getDis();
+            List<String> uniqueNameList = Lists.newLinkedList();
+            for (Map.Entry<String, List<PushBaseDTO>> entry : retMap.entrySet()) {
+                if (ListUtil.isNotEmpty(entry.getValue())) {
+                    uniqueNameList.addAll(entry.getValue().stream()
+                            .map(i -> i.getName())
+                            .collect(Collectors.toList()));
+                }
+            }
+            if (ListUtil.isNotEmpty(uniqueNameList)) {
+                Map<String, Map<String, Long>> uniqueNameMap
+                        = diseaseConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
+                for (Map.Entry<String, List<PushBaseDTO>> entry : retMap.entrySet()) {
+                    if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                        entry.getValue().forEach(item -> {
+                            if (uniqueNameMap.get(item.getName()) != null) {
+                                item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
+                            }
+                        });
+                    }
+                }
+            }
+        }
+        return retMap;
+    }
+
+    @DataProvider("retOperation")
+    public List<PushBaseDTO> retOperation(@InvokeParameter("pushDTO") PushDTO data,
+                                          @InvokeParameter("hospitalId") Long hospitalId) {
+        //手术
+        List<PushBaseDTO> retOperation = new ArrayList<>();
+        if (ListUtil.isNotEmpty(data.getOperations())) {
+            retOperation = data.getOperations();
+            List<String> uniqueNameList = retOperation.stream()
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList());
+            Map<String, Map<String, Long>> uniqueNameMap
+                    = operationConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
+            if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                retOperation.forEach(item -> {
+                    if (uniqueNameMap.get(item.getName()) != null) {
+                        item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
+                    }
+                });
+            }
+        }
+        return retOperation;
+    }
+
+    @DataProvider("retDrug")
+    public List<PushBaseDTO> retDrug(@InvokeParameter("pushDTO") PushDTO data,
+                                     @InvokeParameter("hospitalId") Long hospitalId) {
+        //药品
+        List<PushBaseDTO> retDrug = new ArrayList<>();
+        if (ListUtil.isNotEmpty(data.getMedicines())) {
+            retDrug = data.getMedicines();
+            List<String> uniqueNameList = retDrug.stream()
+                    .map(i -> i.getName())
+                    .collect(Collectors.toList());
+            Map<String, Map<String, Long>> uniqueNameMap
+                    = drugConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
+            if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
+                retDrug.forEach(item -> {
+                    if (uniqueNameMap.get(item.getName()) != null) {
+                        item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
+                    }
+                });
+            }
+        }
+        return retDrug;
+    }
+}

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

@@ -1,25 +1,17 @@
 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.dto.PushBaseDTO;
 import com.diagbot.dto.PushDTO;
 import com.diagbot.entity.HospitalInfo;
 import com.diagbot.enums.IsDeleteEnum;
-import com.diagbot.util.BeanUtil;
-import com.diagbot.util.ListUtil;
-import com.diagbot.util.StringUtil;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.vo.SearchData;
-import com.google.common.collect.Lists;
+import io.github.lvyahui8.spring.facade.DataFacade;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;
 
 /**
  * @Description:
@@ -28,20 +20,8 @@ import java.util.stream.Collectors;
  */
 @Component
 public class AssembleFacade {
-    @Autowired
-    private LisConfigFacade lisConfigFacade;
-    @Autowired
-    private PacsConfigFacade pacsConfigFacade;
-    @Autowired
-    private DiseaseConfigFacade diseaseConfigFacade;
-    @Autowired
-    private DrugConfigFacade drugConfigFacade;
-    @Autowired
-    private OperationConfigFacade operationConfigFacade;
     @Autowired
     private HospitalInfoFacade hospitalInfoFacade;
-    @Autowired
-    private DeptConfigFacade deptConfigFacade;
 
     /**
      * 入参映射
@@ -56,318 +36,17 @@ public class AssembleFacade {
             isConnect = 1;
         }
         if (isConnect.equals(1)) {
-            //化验公表转换
-            List<String> lisHisNameList = Lists.newArrayList();
-            //lis
-            if (ListUtil.isNotEmpty(searchData.getLis())) {
-                lisHisNameList.addAll(searchData.getLis()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList()));
-            }
-            //lisOrder
-            if (ListUtil.isNotEmpty(searchData.getLisOrder())) {
-                lisHisNameList.addAll(searchData.getLisOrder()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .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()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList()));
-            }
-            //pacsOrder
-            if (ListUtil.isNotEmpty(searchData.getPacsOrder())) {
-                pacsHisNameList.addAll(searchData.getPacsOrder()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .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()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList()));
-            }
-            //diagOrder
-            if (ListUtil.isNotEmpty(searchData.getDiagOrder())) {
-                diagHisNameList.addAll(searchData.getDiagOrder()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .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()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList()));
-            }
-            //drugOrder
-            if (ListUtil.isNotEmpty(searchData.getDrugOrder())) {
-                drugHisNameList.addAll(searchData.getDrugOrder()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .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()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .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);
-                }
-            }
-
-            //科室公表转换
-            List<String> deptHisNameList = Lists.newArrayList();
-            //dept
-            if (ListUtil.isNotEmpty(searchData.getDept())) {
-                deptHisNameList.addAll(searchData.getDept()
-                        .stream()
-                        .filter(i -> StringUtil.isNotBlank(i.getName()) || StringUtil.isNotBlank(i.getUniqueName()))
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList()));
-            }
-            deptHisNameList = deptHisNameList
-                    .stream()
-                    .distinct()
-                    .collect(Collectors.toList());
-
-            if (ListUtil.isNotEmpty(deptHisNameList)) {
-                Map<String, Map<String, Long>> configMap
-                        = deptConfigFacade.getConfigMap(searchData.getHospitalId(), deptHisNameList, null);
-                if (ListUtil.isNotEmpty(searchData.getDept())) {
-                    List<Item> convertItem = itemConvert(searchData.getDept(), configMap);
-                    searchData.setDept(convertItem);
-                }
+            try {
+                Map<String, Object> invokeParams = new HashMap<>();
+                invokeParams.put("searchData", searchData);
+                searchData = DataFacade.get("assembleDataAll", invokeParams, SearchData.class);
+            } catch (Exception e) {
+                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "入参映射出错" + e.getMessage());
             }
         }
         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())
-                    || StringUtil.isNotBlank(lisRecord.getUniqueName())) {
-                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())
-                    || StringUtil.isNotBlank(pacsRecord.getUniqueName())) {
-                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())
-                    || StringUtil.isNotBlank(item.getUniqueName())) {
-                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;
-    }
-
     /**
      * 出参映射
      *
@@ -382,99 +61,13 @@ public class AssembleFacade {
             isConnect = 1;
         }
         if (isConnect.equals(1)) {
-            //检验
-            if (ListUtil.isNotEmpty(data.getLis())) {
-                List<PushBaseDTO> retLis = data.getLis();
-                List<String> uniqueNameList = retLis.stream()
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList());
-                Map<String, Map<String, Long>> uniqueNameMap
-                        = lisConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
-                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
-                    retLis.forEach(item -> {
-                        if (uniqueNameMap.get(item.getName()) != null) {
-                            item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
-                        }
-                    });
-                    data.setLis(retLis);
-                }
-            }
-            //检查
-            if (ListUtil.isNotEmpty(data.getPacs())) {
-                List<PushBaseDTO> retPacs = data.getPacs();
-                List<String> uniqueNameList = retPacs.stream()
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList());
-                Map<String, Map<String, Long>> uniqueNameMap
-                        = pacsConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
-                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
-                    retPacs.forEach(item -> {
-                        if (uniqueNameMap.get(item.getName()) != null) {
-                            item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
-                        }
-                    });
-                    data.setPacs(retPacs);
-                }
-            }
-            //诊断
-            if (data.getDis() != null && data.getDis().size() > 0) {
-                Map<String, List<PushBaseDTO>> retMap = data.getDis();
-                List<String> uniqueNameList = Lists.newLinkedList();
-                for (Map.Entry<String, List<PushBaseDTO>> entry : retMap.entrySet()) {
-                    if (ListUtil.isNotEmpty(entry.getValue())) {
-                        uniqueNameList.addAll(entry.getValue().stream()
-                                .map(i -> i.getName())
-                                .collect(Collectors.toList()));
-                    }
-                }
-                if (ListUtil.isNotEmpty(uniqueNameList)) {
-                    Map<String, Map<String, Long>> uniqueNameMap
-                            = diseaseConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
-                    for (Map.Entry<String, List<PushBaseDTO>> entry : retMap.entrySet()) {
-                        if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
-                            entry.getValue().forEach(item -> {
-                                if (uniqueNameMap.get(item.getName()) != null) {
-                                    item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
-                                }
-                            });
-                        }
-                    }
-                    data.setDis(retMap);
-                }
-            }
-            //手术
-            if (ListUtil.isNotEmpty(data.getOperations())) {
-                List<PushBaseDTO> retOperation = data.getOperations();
-                List<String> uniqueNameList = retOperation.stream()
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList());
-                Map<String, Map<String, Long>> uniqueNameMap
-                        = operationConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
-                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
-                    retOperation.forEach(item -> {
-                        if (uniqueNameMap.get(item.getName()) != null) {
-                            item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
-                        }
-                    });
-                    data.setPacs(retOperation);
-                }
-            }
-            //药品
-            if (ListUtil.isNotEmpty(data.getMedicines())) {
-                List<PushBaseDTO> retDrug = data.getMedicines();
-                List<String> uniqueNameList = retDrug.stream()
-                        .map(i -> i.getName())
-                        .collect(Collectors.toList());
-                Map<String, Map<String, Long>> uniqueNameMap
-                        = drugConfigFacade.getUniqueNameConfigMap(hospitalId, null, uniqueNameList);
-                if (uniqueNameMap != null && uniqueNameMap.size() > 0) {
-                    retDrug.forEach(item -> {
-                        if (uniqueNameMap.get(item.getName()) != null) {
-                            item.setHisNameList(new ArrayList<>(uniqueNameMap.get(item.getName()).keySet()));
-                        }
-                    });
-                    data.setPacs(retDrug);
-                }
+            try {
+                Map<String, Object> invokeParams = new HashMap<>();
+                invokeParams.put("pushDTO", data);
+                invokeParams.put("hospitalId", hospitalId);
+                data = DataFacade.get("assemblePushAll", invokeParams, PushDTO.class);
+            } catch (Exception e) {
+                throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "出参映射出错" + e.getMessage());
             }
         }
         return data;