1、术语导入过滤空行

src/main/java/com/diagbot/entity/DeptConfig.java

@@ -201,12 +201,13 @@ public class DeptConfig implements Serializable {
                 && Objects.equals(isDeleted, deptConfig.isDeleted)
                 && Objects.equals(hospitalId, deptConfig.hospitalId)
                 && Objects.equals(hisName, deptConfig.hisName)
+                && Objects.equals(hisCode, deptConfig.hisCode)
                 && Objects.equals(uniqueName, deptConfig.uniqueName)
                 && Objects.equals(uniqueCode, deptConfig.uniqueCode);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(id, isDeleted, hospitalId, hisName, uniqueName, uniqueCode);
+        return Objects.hash(id, isDeleted, hospitalId, hisName, hisCode, uniqueName, uniqueCode);
     }
 }

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

@@ -247,16 +247,19 @@ public class DeptConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        deptConfigList = deptConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getHisCode())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(deptConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
+
         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())
-                    && StringUtil.isBlank(deptConfigList.get(i).getUniqueName())
-                    && StringUtil.isBlank(deptConfigList.get(i).getUniqueCode())) {
-                continue;
-            }
-            isEmpty = false;
             if (StringUtil.isBlank(deptConfigList.get(i).getHisName())
                     || StringUtil.isBlank(deptConfigList.get(i).getUniqueName())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -264,6 +267,9 @@ public class DeptConfigFacade {
             if (StringUtil.isNotBlank(deptConfigList.get(i).getHisName())) {
                 deptConfigList.get(i).setHisName(deptConfigList.get(i).getHisName().trim());
             }
+            if (StringUtil.isNotBlank(deptConfigList.get(i).getHisCode())) {
+                deptConfigList.get(i).setHisCode(deptConfigList.get(i).getHisCode().trim());
+            }
             if (StringUtil.isNotBlank(deptConfigList.get(i).getUniqueName())) {
                 deptConfigList.get(i).setUniqueName(deptConfigList.get(i).getUniqueName().trim());
             }
@@ -273,11 +279,9 @@ public class DeptConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -316,24 +320,17 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }
 
-
         //重复数据过滤
         deptConfigList = deptConfigList
                 .stream()

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

@@ -248,19 +248,20 @@ public class DiseaseConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        diseaseConfigList = diseaseConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getIcdCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(diseaseConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         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())) {
                 emptyNumList.add(String.valueOf(i + 2));
-
             }
             if (StringUtil.isNotBlank(diseaseConfigList.get(i).getHisName())) {
                 diseaseConfigList.get(i).setHisName(diseaseConfigList.get(i).getHisName().trim());
@@ -274,11 +275,9 @@ public class DiseaseConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -318,18 +317,13 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }

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

@@ -273,7 +273,16 @@ public class DrugConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        drugConfigList = drugConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getForm())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(drugConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         List<String> emptyNumList = Lists.newLinkedList();
         for (int i = 0; i < drugConfigList.size(); i++) {
             if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
@@ -282,7 +291,6 @@ public class DrugConfigFacade {
                     && StringUtil.isBlank(drugConfigList.get(i).getUniqueCode())) {
                 continue;
             }
-            isEmpty = false;
             if (StringUtil.isBlank(drugConfigList.get(i).getHisName())
                     || StringUtil.isBlank(drugConfigList.get(i).getUniqueName())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -302,15 +310,14 @@ public class DrugConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
 
+
         List<String> hisNames = drugConfigList
                 .stream()
                 .map(i -> i.getHisName())
@@ -353,19 +360,13 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }

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

@@ -277,16 +277,18 @@ public class LisConfigFacade{
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        lisConfigList = lisConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getHisDetailName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(lisConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         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).getUniqueName())
-                    && StringUtil.isBlank(lisConfigList.get(i).getUniqueCode())) {
-                continue;
-            }
-            isEmpty = false;
             if (StringUtil.isBlank(lisConfigList.get(i).getHisName())
                     || StringUtil.isBlank(lisConfigList.get(i).getUniqueName())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -303,11 +305,9 @@ public class LisConfigFacade{
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -367,12 +367,6 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
@@ -380,7 +374,7 @@ public class LisConfigFacade{
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }

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

@@ -247,15 +247,17 @@ public class OperationConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        operationConfigList = operationConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(operationConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         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())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -272,11 +274,9 @@ public class OperationConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -315,18 +315,13 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }

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

@@ -247,15 +247,17 @@ public class PacsConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        pacsConfigList = pacsConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(pacsConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         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())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -272,11 +274,9 @@ public class PacsConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -315,18 +315,13 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }

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

@@ -228,7 +228,7 @@ public class TransfusionConfigFacade {
     public void importExcel(MultipartFile file) {
         List<TransfusionConfig> transfusionConfigList = ExcelUtils.importExcel(file, 0, 1, TransfusionConfig.class);
         if (ListUtil.isNotEmpty(transfusionConfigList)) {
-            saveOrUpdateRecords(transfusionConfigList);
+            importExcelRecords(transfusionConfigList);
         }else {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
         }
@@ -247,15 +247,17 @@ public class TransfusionConfigFacade {
 
         //1、数据完整性校验
         //2、去除前后空格
-        Boolean isEmpty = true;
+        //过滤空数据，保留重复数据，方便计行
+        transfusionConfigList = transfusionConfigList.stream()
+                .filter(i -> StringUtil.isNotBlank(i.getHisName())
+                        || StringUtil.isNotBlank(i.getUniqueCode())
+                        || StringUtil.isNotBlank(i.getUniqueName()))
+                .collect(Collectors.toList());
+        if (ListUtil.isEmpty(transfusionConfigList)) {
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "校验失败，导入数据不能为空");
+        }
         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())) {
                 emptyNumList.add(String.valueOf(i + 2));
@@ -272,11 +274,9 @@ public class TransfusionConfigFacade {
                 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, "以下行数存在不完整数据："
+            throw new CommonException(CommonErrorCode.PARAM_IS_NULL, "以下行数（不计入空行）存在不完整数据："
                     + emptyNumList.stream().collect(Collectors.joining("、"))
                     + "。导入取消，请修改后再试。\n");
         }
@@ -315,18 +315,13 @@ 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())) {
                 errorNumList.add(String.valueOf(i + 2));
             }
         }
         if (ListUtil.isNotEmpty(errorNumList)) {
             throw new CommonException(CommonErrorCode.PARAM_IS_NULL,
-                    "以下行数标准术语与数据库术语不匹配："
+                    "以下行数（不计入空行）标准术语与数据库术语不匹配："
                             + errorNumList.stream().collect(Collectors.joining("、"))
                             + "。导入取消，请修改后再试。");
         }