数据导入校验

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.DiseaseConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.DiseaseConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.DiseaseConfigListVO;
 import com.diagbot.vo.DiseaseConfigPageVO;
 import com.diagbot.vo.IdListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class DiseaseConfigFacade {
     @Autowired
     private DiseaseConfigService diseaseConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -206,8 +215,90 @@ public class DiseaseConfigFacade {
     public void importExcel(MultipartFile file) {
         List<DiseaseConfig> diseaseConfigList = ExcelUtils.importExcel(file, 0, 1, DiseaseConfig.class);
         if (ListUtil.isNotEmpty(diseaseConfigList)) {
-            saveOrUpdateRecords(diseaseConfigList);
+            importExcelRecords(diseaseConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param diseaseConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<DiseaseConfig> diseaseConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < diseaseConfigList.size(); i++) {
+            if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
+            diseaseConfigList.get(i).setUniqueName(diseaseConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getIcdCode())) {
+                diseaseConfigList.get(i).setIcdCode(diseaseConfigList.get(i).getIcdCode().trim());
+            } else {
+                diseaseConfigList.get(i).setIcdCode(null);
+            }
+        }
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Long>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), null, null);
+        diseaseConfigList.forEach(diseaseConfig -> {
+            diseaseConfig.setHospitalId(Long.valueOf(hospitalId));
+            diseaseConfig.setModifier(userId);
+            diseaseConfig.setGmtModified(now);
+            if (diseaseConfig.getId() == null) {
+                if (configMap.containsKey(diseaseConfig.getHisName())) {
+                    deleteIds.add(configMap.get(diseaseConfig.getHisName()).get(diseaseConfig.getUniqueName()));
+                }
+                diseaseConfig.setCreator(userId);
+                diseaseConfig.setGmtCreate(now);
+            }
+            if (diseaseConfig.getIsDeleted() == null) {
+                diseaseConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        List<String> uniqueNames = diseaseConfigList.stream()
+                .map(i -> i.getUniqueName())
+                .distinct()
+                .collect(Collectors.toList());
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.Disease.getKey());
+        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
+        List<String> names = respDTO.data;
+        for (int i = 0; i < diseaseConfigList.size(); i++) {
+            if (!names.contains(diseaseConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + diseaseConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
         }
+
+        //重复数据过滤
+        diseaseConfigList = diseaseConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        diseaseConfigService.saveOrUpdateBatch(diseaseConfigList);
+        return true;
     }
 
     /**

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.DrugConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.DrugConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.DrugConfigListVO;
 import com.diagbot.vo.DrugConfigPageVO;
 import com.diagbot.vo.IdListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class DrugConfigFacade {
     @Autowired
     private DrugConfigService drugConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -232,8 +241,98 @@ public class DrugConfigFacade {
     public void importExcel(MultipartFile file) {
         List<DrugConfig> drugConfigList = ExcelUtils.importExcel(file, 0, 1, DrugConfig.class);
         if (ListUtil.isNotEmpty(drugConfigList)) {
-            saveOrUpdateRecords(drugConfigList);
+            importExcelRecords(drugConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param drugConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<DrugConfig> drugConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < drugConfigList.size(); i++) {
+            if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(drugConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            drugConfigList.get(i).setHisName(drugConfigList.get(i).getHisName().trim());
+            drugConfigList.get(i).setUniqueName(drugConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getUniqueCode())) {
+                drugConfigList.get(i).setUniqueCode(drugConfigList.get(i).getUniqueCode().trim());
+            } else {
+                drugConfigList.get(i).setUniqueCode(null);
+            }
         }
+
+        List<String> hisNames = drugConfigList
+                .stream()
+                .map(i -> i.getHisName())
+                .collect(Collectors.toList());
+        List<String> uniqueNames = drugConfigList
+                .stream()
+                .map(i -> i.getUniqueName())
+                .collect(Collectors.toList());
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Map<String, Long>>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), hisNames, uniqueNames);
+        drugConfigList.forEach(drugConfig -> {
+            drugConfig.setHospitalId(Long.valueOf(hospitalId));
+            drugConfig.setModifier(userId);
+            drugConfig.setGmtModified(now);
+            String form = StringUtil.isBlank(drugConfig.getForm()) ? "" : drugConfig.getForm();
+            if (drugConfig.getId() == null) {
+                if (configMap.get(drugConfig.getHisName()) != null
+                        && configMap.get(drugConfig.getHisName()).get(form) != null
+                        && configMap.get(drugConfig.getHisName()).get(form).get(drugConfig.getUniqueName()) != null) {
+                    deleteIds.add(configMap.get(drugConfig.getHisName()).get(form).get(drugConfig.getUniqueName()));
+                }
+                drugConfig.setCreator(userId);
+                drugConfig.setGmtCreate(now);
+            }
+            if (drugConfig.getIsDeleted() == null) {
+                drugConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.Drug.getKey());
+        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
+        List<String> names = respDTO.data;
+        for (int i = 0; i < drugConfigList.size(); i++) {
+            if (!names.contains(drugConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + drugConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
+        }
+
+        //重复数据过滤
+        drugConfigList = drugConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        drugConfigService.saveOrUpdateBatch(drugConfigList);
+        return true;
     }
 
     /**

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.LisConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.LisConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.IdListVO;
 import com.diagbot.vo.IdVO;
 import com.diagbot.vo.LisConfigListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class LisConfigFacade{
     @Autowired
     private LisConfigService lisConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -236,8 +245,112 @@ public class LisConfigFacade{
         //从Excel读取数据
         List<LisConfig> lisConfigList = ExcelUtils.importExcel(file, 0, 1, LisConfig.class);
         if (ListUtil.isNotEmpty(lisConfigList)) {
-            saveOrUpdateRecords(lisConfigList);
+            importExcelRecords(lisConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param lisConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<LisConfig> lisConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < lisConfigList.size(); i++) {
+            if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(lisConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            lisConfigList.get(i).setHisName(lisConfigList.get(i).getHisName().trim());
+            lisConfigList.get(i).setUniqueName(lisConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(lisConfigList.get(i).getUniqueCode())) {
+                lisConfigList.get(i).setUniqueCode(lisConfigList.get(i).getUniqueCode().trim());
+            } else {
+                lisConfigList.get(i).setUniqueCode(null);
+            }
+        }
+
+        List<String> hisNames = lisConfigList
+                .stream()
+                .map(i -> i.getHisName())
+                .collect(Collectors.toList());
+        List<String> uniqueNames = lisConfigList
+                .stream()
+                .map(i -> i.getUniqueName())
+                .collect(Collectors.toList());
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Map<String, Long>>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), hisNames, uniqueNames);
+        lisConfigList.forEach(lisConfig -> {
+            lisConfig.setHospitalId(Long.valueOf(hospitalId));
+            lisConfig.setModifier(userId);
+            lisConfig.setGmtModified(now);
+            if (lisConfig.getId() == null) {
+                if (configMap.containsKey(lisConfig.getHisName())) {
+                    if (lisConfig.getHisDetailName() == null
+                            && configMap.get(lisConfig.getHisName()).containsKey("")) {
+                        if (configMap.get(lisConfig.getHisName()).get("").containsKey(lisConfig.getUniqueName())) {
+                            deleteIds.add(configMap.get(lisConfig.getHisName()).get("").get(lisConfig.getUniqueName()));
+                        }
+                    } else if (configMap.get(lisConfig.getHisName()).containsKey(lisConfig.getHisDetailName())) {
+                        if (configMap.get(lisConfig.getHisName()).get(lisConfig.getHisDetailName()).containsKey(lisConfig.getUniqueName())) {
+                            deleteIds.add(configMap
+                                    .get(lisConfig.getHisName())
+                                    .get(lisConfig.getHisDetailName())
+                                    .get(lisConfig.getUniqueName()));
+                        }
+                    }
+                }
+                lisConfig.setCreator(userId);
+                lisConfig.setGmtCreate(now);
+            }
+            if (lisConfig.getIsDeleted() == null) {
+                lisConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.LisPack.getKey());
+        RespDTO<List<String>> respLisPackDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respLisPackDTO, "标准术语校验失败");
+        List<String> lisPackNames = respLisPackDTO.data;
+        conceptVO.setType(ConceptTypeEnum.Lis.getKey());
+        RespDTO<List<String>> respLisDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respLisDTO, "标准术语校验失败");
+        List<String> lisNames = respLisDTO.data;
+        for (int i = 0; i < lisConfigList.size(); i++) {
+            if (!lisPackNames.contains(lisConfigList.get(i).getUniqueName())
+                    && !lisNames.contains(lisConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + lisConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
         }
+
+        //重复数据过滤
+        lisConfigList = lisConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        lisConfigService.saveOrUpdateBatch(lisConfigList);
+        return true;
     }
 
 

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.OperationConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.OperationConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.IdListVO;
 import com.diagbot.vo.IdVO;
 import com.diagbot.vo.OperationConfigListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class OperationConfigFacade {
     @Autowired
     private OperationConfigService operationConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -206,8 +215,90 @@ public class OperationConfigFacade {
     public void importExcel(MultipartFile file) {
         List<OperationConfig> operationConfigList = ExcelUtils.importExcel(file, 0, 1, OperationConfig.class);
         if (ListUtil.isNotEmpty(operationConfigList)) {
-            saveOrUpdateRecords(operationConfigList);
+            importExcelRecords(operationConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param operationConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<OperationConfig> operationConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < operationConfigList.size(); i++) {
+            if (StringUtil.isBlank(operationConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(operationConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            operationConfigList.get(i).setHisName(operationConfigList.get(i).getHisName().trim());
+            operationConfigList.get(i).setUniqueName(operationConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(operationConfigList.get(i).getUniqueCode())) {
+                operationConfigList.get(i).setUniqueCode(operationConfigList.get(i).getUniqueCode().trim());
+            } else {
+                operationConfigList.get(i).setUniqueCode(null);
+            }
+        }
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Long>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), null, null);
+        operationConfigList.forEach(operationConfig -> {
+            operationConfig.setHospitalId(Long.valueOf(hospitalId));
+            operationConfig.setModifier(userId);
+            operationConfig.setGmtModified(now);
+            if (operationConfig.getId() == null) {
+                if (configMap.containsKey(operationConfig.getHisName())) {
+                    deleteIds.add(configMap.get(operationConfig.getHisName()).get(operationConfig.getUniqueName()));
+                }
+                operationConfig.setCreator(userId);
+                operationConfig.setGmtCreate(now);
+            }
+            if (operationConfig.getIsDeleted() == null) {
+                operationConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        List<String> uniqueNames = operationConfigList.stream()
+                .map(i -> i.getUniqueName())
+                .distinct()
+                .collect(Collectors.toList());
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.Opeartion.getKey());
+        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
+        List<String> names = respDTO.data;
+        for (int i = 0; i < operationConfigList.size(); i++) {
+            if (!names.contains(operationConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + operationConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
         }
+
+        //重复数据过滤
+        operationConfigList = operationConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        operationConfigService.saveOrUpdateBatch(operationConfigList);
+        return true;
     }
 
     /**

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.PacsConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.PacsConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.IdListVO;
 import com.diagbot.vo.IdVO;
 import com.diagbot.vo.PacsConfigListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class PacsConfigFacade {
     @Autowired
     private PacsConfigService pacsConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -206,8 +215,90 @@ public class PacsConfigFacade {
     public void importExcel(MultipartFile file) {
         List<PacsConfig> pacsConfigList = ExcelUtils.importExcel(file, 0, 1, PacsConfig.class);
         if (ListUtil.isNotEmpty(pacsConfigList)) {
-            saveOrUpdateRecords(pacsConfigList);
+            importExcelRecords(pacsConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param pacsConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<PacsConfig> pacsConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < pacsConfigList.size(); i++) {
+            if (StringUtil.isBlank(pacsConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(pacsConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            pacsConfigList.get(i).setHisName(pacsConfigList.get(i).getHisName().trim());
+            pacsConfigList.get(i).setUniqueName(pacsConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(pacsConfigList.get(i).getUniqueCode())) {
+                pacsConfigList.get(i).setUniqueCode(pacsConfigList.get(i).getUniqueCode().trim());
+            } else {
+                pacsConfigList.get(i).setUniqueCode(null);
+            }
+        }
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Long>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), null, null);
+        pacsConfigList.forEach(pacsConfig -> {
+            pacsConfig.setHospitalId(Long.valueOf(hospitalId));
+            pacsConfig.setModifier(userId);
+            pacsConfig.setGmtModified(now);
+            if (pacsConfig.getId() == null) {
+                if (configMap.containsKey(pacsConfig.getHisName())) {
+                    deleteIds.add(configMap.get(pacsConfig.getHisName()).get(pacsConfig.getUniqueName()));
+                }
+                pacsConfig.setCreator(userId);
+                pacsConfig.setGmtCreate(now);
+            }
+            if (pacsConfig.getIsDeleted() == null) {
+                pacsConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        List<String> uniqueNames = pacsConfigList.stream()
+                .map(i -> i.getUniqueName())
+                .distinct()
+                .collect(Collectors.toList());
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.Pacs.getKey());
+        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
+        List<String> names = respDTO.data;
+        for (int i = 0; i < pacsConfigList.size(); i++) {
+            if (!names.contains(pacsConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + pacsConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
         }
+
+        //重复数据过滤
+        pacsConfigList = pacsConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        pacsConfigService.saveOrUpdateBatch(pacsConfigList);
+        return true;
     }
 
     /**
@@ -289,4 +380,4 @@ public class PacsConfigFacade {
         String fileName = "检查映射.xls";
         ExcelUtils.exportExcel(records, null, "sheet1", PacsConfig.class, fileName, response, 12.8f);
     }
-}
+}

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

@@ -3,15 +3,22 @@ package com.diagbot.facade;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.diagbot.client.CdssCoreClient;
+import com.diagbot.dto.RespDTO;
 import com.diagbot.entity.TransfusionConfig;
+import com.diagbot.enums.ConceptTypeEnum;
 import com.diagbot.enums.IsDeleteEnum;
+import com.diagbot.exception.CommonErrorCode;
+import com.diagbot.exception.CommonException;
 import com.diagbot.service.TransfusionConfigService;
 import com.diagbot.util.DateUtil;
 import com.diagbot.util.EntityUtil;
 import com.diagbot.util.ExcelUtils;
 import com.diagbot.util.ListUtil;
+import com.diagbot.util.RespDTOUtil;
 import com.diagbot.util.StringUtil;
 import com.diagbot.util.SysUserUtils;
+import com.diagbot.vo.ConceptVO;
 import com.diagbot.vo.IdListVO;
 import com.diagbot.vo.IdVO;
 import com.diagbot.vo.TransfusionConfigListVO;
@@ -37,6 +44,8 @@ import java.util.stream.Collectors;
 public class TransfusionConfigFacade {
     @Autowired
     private TransfusionConfigService transfusionConfigService;
+    @Autowired
+    private CdssCoreClient cdssCoreClient;
 
     /**
      * 判断是否已存在
@@ -207,7 +216,89 @@ public class TransfusionConfigFacade {
         List<TransfusionConfig> transfusionConfigList = ExcelUtils.importExcel(file, 0, 1, TransfusionConfig.class);
         if (ListUtil.isNotEmpty(transfusionConfigList)) {
             saveOrUpdateRecords(transfusionConfigList);
+        }else {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+    }
+
+    /**
+     * 数据导入
+     *
+     * @param transfusionConfigList
+     * @return
+     */
+    public Boolean importExcelRecords(List<TransfusionConfig> transfusionConfigList) {
+        String hospitalId = SysUserUtils.getCurrentHospitalID();
+        String userId = SysUserUtils.getCurrentPrincipleID();
+        Date now = DateUtil.now();
+
+        //1、数据完整性校验
+        //2、去除前后空格
+        for (int i = 0; i < transfusionConfigList.size(); i++) {
+            if (StringUtil.isBlank(transfusionConfigList.get(i).getHisName())
+                    || StringUtil.isBlank(transfusionConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+            }
+            transfusionConfigList.get(i).setHisName(transfusionConfigList.get(i).getHisName().trim());
+            transfusionConfigList.get(i).setUniqueName(transfusionConfigList.get(i).getUniqueName().trim());
+            if (StringUtil.isNotBlank(transfusionConfigList.get(i).getUniqueCode())) {
+                transfusionConfigList.get(i).setUniqueCode(transfusionConfigList.get(i).getUniqueCode().trim());
+            } else {
+                transfusionConfigList.get(i).setUniqueCode(null);
+            }
+        }
+
+        // 验证数据是否已存在，已存在的先删除
+        // 没id的删除重新插入，有id的更新
+        List<Long> deleteIds = Lists.newLinkedList();
+        Map<String, Map<String, Long>> configMap
+                = getConfigMap(Long.valueOf(hospitalId), null, null);
+        transfusionConfigList.forEach(transfusionConfig -> {
+            transfusionConfig.setHospitalId(Long.valueOf(hospitalId));
+            transfusionConfig.setModifier(userId);
+            transfusionConfig.setGmtModified(now);
+            if (transfusionConfig.getId() == null) {
+                if (configMap.containsKey(transfusionConfig.getHisName())) {
+                    deleteIds.add(configMap.get(transfusionConfig.getHisName()).get(transfusionConfig.getUniqueName()));
+                }
+                transfusionConfig.setCreator(userId);
+                transfusionConfig.setGmtCreate(now);
+            }
+            if (transfusionConfig.getIsDeleted() == null) {
+                transfusionConfig.setIsDeleted(IsDeleteEnum.N.getKey());
+            }
+        });
+
+        //标准术语校验
+        List<String> uniqueNames = transfusionConfigList.stream()
+                .map(i -> i.getUniqueName())
+                .distinct()
+                .collect(Collectors.toList());
+        ConceptVO conceptVO = new ConceptVO();
+        conceptVO.setNames(uniqueNames);
+        conceptVO.setType(ConceptTypeEnum.Transfusion.getKey());
+        RespDTO<List<String>> respDTO = cdssCoreClient.getConceptNames(conceptVO);
+        RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
+        List<String> names = respDTO.data;
+        for (int i = 0; i < transfusionConfigList.size(); i++) {
+            if (!names.contains(transfusionConfigList.get(i).getUniqueName())) {
+                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                        "【" + transfusionConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+            }
         }
+
+        //重复数据过滤
+        transfusionConfigList = transfusionConfigList
+                .stream()
+                .distinct()
+                .collect(Collectors.toList());
+
+        //删除已存在映射关系
+        IdListVO idListVO = new IdListVO();
+        idListVO.setIds(deleteIds);
+        deleteRecords(idListVO);
+        transfusionConfigService.saveOrUpdateBatch(transfusionConfigList);
+        return true;
     }
 
     /**