1、术语导入校验

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

@@ -247,6 +247,8 @@ public class DeptConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < deptConfigList.size(); i++) {
             if (StringUtil.isBlank(deptConfigList.get(i).getHisName())
                     && StringUtil.isBlank(deptConfigList.get(i).getHisCode())
@@ -254,18 +256,31 @@ public class DeptConfigFacade {
                     && StringUtil.isBlank(deptConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(deptConfigList.get(i).getHisName())
                     || StringUtil.isBlank(deptConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getHisName())) {
+                deptConfigList.get(i).setHisName(deptConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getUniqueName())) {
+                deptConfigList.get(i).setUniqueName(deptConfigList.get(i).getUniqueName().trim());
             }
-            deptConfigList.get(i).setHisName(deptConfigList.get(i).getHisName().trim());
-            deptConfigList.get(i).setUniqueName(deptConfigList.get(i).getUniqueName().trim());
             if (StringUtil.isNotBlank(deptConfigList.get(i).getUniqueCode())) {
                 deptConfigList.get(i).setUniqueCode(deptConfigList.get(i).getUniqueCode().trim());
             } else {
                 deptConfigList.get(i).setUniqueCode(null);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
@@ -289,6 +304,7 @@ public class DeptConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = deptConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -300,11 +316,23 @@ public class DeptConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < deptConfigList.size(); i++) {
+            if (StringUtil.isBlank(deptConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(deptConfigList.get(i).getHisCode())
+                    && StringUtil.isBlank(deptConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(deptConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!names.contains(deptConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + deptConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
+
 
         //重复数据过滤
         deptConfigList = deptConfigList

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

@@ -245,26 +245,44 @@ public class DiseaseConfigFacade {
         String userId = SysUserUtils.getCurrentPrincipleID();
         Date now = DateUtil.now();
 
+
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < diseaseConfigList.size(); i++) {
             if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
                     && StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(diseaseConfigList.get(i).getIcdCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
                     || StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+
+            }
+            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getHisName())) {
+                diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(diseaseConfigList.get(i).getUniqueName())) {
+                diseaseConfigList.get(i).setUniqueName(diseaseConfigList.get(i).getUniqueName().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
+
 
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
@@ -288,6 +306,7 @@ public class DiseaseConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = diseaseConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -299,11 +318,21 @@ public class DiseaseConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < diseaseConfigList.size(); i++) {
+            if (StringUtil.isBlank(diseaseConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(diseaseConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(diseaseConfigList.get(i).getIcdCode())) {
+                continue;
+            }
             if (!names.contains(diseaseConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + diseaseConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         diseaseConfigList = diseaseConfigList

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

@@ -273,25 +273,43 @@ public class DrugConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < drugConfigList.size(); i++) {
             if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
-                    &&StringUtil.isBlank(drugConfigList.get(i).getForm())
+                    && StringUtil.isBlank(drugConfigList.get(i).getForm())
                     && StringUtil.isBlank(drugConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(drugConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
                     || StringUtil.isBlank(drugConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getHisName())) {
+                drugConfigList.get(i).setHisName(drugConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getUniqueName())) {
+                drugConfigList.get(i).setUniqueName(drugConfigList.get(i).getUniqueName().trim());
+            }
+            if (StringUtil.isNotBlank(drugConfigList.get(i).getForm())) {
+                drugConfigList.get(i).setUniqueName(drugConfigList.get(i).getForm().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         List<String> hisNames = drugConfigList
                 .stream()
@@ -327,6 +345,7 @@ public class DrugConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         ConceptVO conceptVO = new ConceptVO();
         conceptVO.setNames(uniqueNames);
         conceptVO.setType(ConceptTypeEnum.Drug.getKey());
@@ -334,11 +353,22 @@ public class DrugConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < drugConfigList.size(); i++) {
+            if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(drugConfigList.get(i).getForm())
+                    && StringUtil.isBlank(drugConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(drugConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!names.contains(drugConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + drugConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         drugConfigList = drugConfigList

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

@@ -277,25 +277,40 @@ public class LisConfigFacade{
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < lisConfigList.size(); i++) {
             if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
-                    &&StringUtil.isBlank(lisConfigList.get(i).getHisDetailName())
+                    && StringUtil.isBlank(lisConfigList.get(i).getHisDetailName())
                     && StringUtil.isBlank(lisConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(lisConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
                     || StringUtil.isBlank(lisConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(lisConfigList.get(i).getHisName())) {
+                lisConfigList.get(i).setHisName(lisConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(lisConfigList.get(i).getUniqueName())) {
+                lisConfigList.get(i).setUniqueName(lisConfigList.get(i).getUniqueName().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         List<String> hisNames = lisConfigList
                 .stream()
@@ -340,6 +355,7 @@ public class LisConfigFacade{
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         ConceptVO conceptVO = new ConceptVO();
         conceptVO.setNames(uniqueNames);
         conceptVO.setType(ConceptTypeEnum.LisPack.getKey());
@@ -351,12 +367,23 @@ public class LisConfigFacade{
         RespDTOUtil.respNGDealCover(respLisDTO, "标准术语校验失败");
         List<String> lisNames = respLisDTO.data;
         for (int i = 0; i < lisConfigList.size(); i++) {
+            if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(lisConfigList.get(i).getHisDetailName())
+                    && StringUtil.isBlank(lisConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(lisConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!lisPackNames.contains(lisConfigList.get(i).getUniqueName())
                     && !lisNames.contains(lisConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + lisConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         lisConfigList = lisConfigList

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

@@ -247,24 +247,39 @@ public class OperationConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < operationConfigList.size(); i++) {
             if (StringUtil.isBlank(operationConfigList.get(i).getHisName())
                     && StringUtil.isBlank(operationConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(operationConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(operationConfigList.get(i).getHisName())
                     || StringUtil.isBlank(operationConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(operationConfigList.get(i).getHisName())) {
+                operationConfigList.get(i).setHisName(operationConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(operationConfigList.get(i).getUniqueName())) {
+                operationConfigList.get(i).setUniqueName(operationConfigList.get(i).getUniqueName().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
@@ -288,6 +303,7 @@ public class OperationConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = operationConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -299,11 +315,21 @@ public class OperationConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < operationConfigList.size(); i++) {
+            if (StringUtil.isBlank(operationConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(operationConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(operationConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!names.contains(operationConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + operationConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         operationConfigList = operationConfigList

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

@@ -247,24 +247,39 @@ public class PacsConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < pacsConfigList.size(); i++) {
             if (StringUtil.isBlank(pacsConfigList.get(i).getHisName())
                     && StringUtil.isBlank(pacsConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(pacsConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(pacsConfigList.get(i).getHisName())
                     || StringUtil.isBlank(pacsConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(pacsConfigList.get(i).getHisName())) {
+                pacsConfigList.get(i).setHisName(pacsConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(pacsConfigList.get(i).getUniqueName())) {
+                pacsConfigList.get(i).setUniqueName(pacsConfigList.get(i).getUniqueName().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
@@ -288,6 +303,7 @@ public class PacsConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = pacsConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -299,11 +315,21 @@ public class PacsConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < pacsConfigList.size(); i++) {
+            if (StringUtil.isBlank(pacsConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(pacsConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(pacsConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!names.contains(pacsConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + pacsConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         pacsConfigList = pacsConfigList

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

@@ -247,24 +247,39 @@ public class TransfusionConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
+        Boolean isEmpty = true;
+        List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < transfusionConfigList.size(); i++) {
             if (StringUtil.isBlank(transfusionConfigList.get(i).getHisName())
                     && StringUtil.isBlank(transfusionConfigList.get(i).getUniqueName())
                     && StringUtil.isBlank(transfusionConfigList.get(i).getUniqueCode())) {
                 continue;
             }
+            isEmpty = false;
             if (StringUtil.isBlank(transfusionConfigList.get(i).getHisName())
                     || StringUtil.isBlank(transfusionConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "第" + (i + 2) + "行存在不完整数据，导入失败，请修改后再试");
+                emptyNumList.add(String.valueOf(i + 2));
+            }
+            if (StringUtil.isNotBlank(transfusionConfigList.get(i).getHisName())) {
+                transfusionConfigList.get(i).setHisName(transfusionConfigList.get(i).getHisName().trim());
+            }
+            if (StringUtil.isNotBlank(transfusionConfigList.get(i).getUniqueName())) {
+                transfusionConfigList.get(i).setUniqueName(transfusionConfigList.get(i).getUniqueName().trim());
             }
-            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);
             }
         }
+        if (isEmpty == true) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+        if (ListUtil.isNotEmpty(emptyNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数存在不完整数据："
+                    + emptyNumList.stream().collect(Collectors.joining("、"))
+                    + "。导入取消，请修改后再试。\n");
+        }
 
         // 验证数据是否已存在，已存在的先删除
         // 没id的删除重新插入，有id的更新
@@ -288,6 +303,7 @@ public class TransfusionConfigFacade {
         });
 
         //标准术语校验
+        List<String> errorNumList = Lists.newLinkedList();
         List<String> uniqueNames = transfusionConfigList.stream()
                 .map(i -> i.getUniqueName())
                 .distinct()
@@ -299,11 +315,21 @@ public class TransfusionConfigFacade {
         RespDTOUtil.respNGDealCover(respDTO, "标准术语校验失败");
         List<String> names = respDTO.data;
         for (int i = 0; i < transfusionConfigList.size(); i++) {
+            if (StringUtil.isBlank(transfusionConfigList.get(i).getHisName())
+                    && StringUtil.isBlank(transfusionConfigList.get(i).getUniqueName())
+                    && StringUtil.isBlank(transfusionConfigList.get(i).getUniqueCode())) {
+                continue;
+            }
             if (!names.contains(transfusionConfigList.get(i).getUniqueName())) {
-                throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                        "【" + transfusionConfigList.get(i).getUniqueName() + "】不是标准术语，导入失败，请修改后再试");
+                errorNumList.add(String.valueOf(i + 2));
             }
         }
+        if (ListUtil.isNotEmpty(errorNumList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
+                    "以下行数标准术语与数据库术语不匹配："
+                            + errorNumList.stream().collect(Collectors.joining("、"))
+                            + "。导入取消，请修改后再试。");
+        }
 
         //重复数据过滤
         transfusionConfigList = transfusionConfigList